[INFO] cloning repository https://github.com/elbaro/zero-mysql
[INFO] running `Command { std: "git" "-c" "credential.helper=" "-c" "credential.helper=/workspace/cargo-home/bin/git-credential-null" "clone" "--bare" "https://github.com/elbaro/zero-mysql" "/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2Felbaro%2Fzero-mysql", kill_on_drop: false }`
[INFO] [stderr] Cloning into bare repository '/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2Felbaro%2Fzero-mysql'...
[INFO] running `Command { std: "git" "rev-parse" "HEAD", kill_on_drop: false }`
[INFO] [stdout] 4bf269de0e1117db974594c5307a47444d759dd6
[INFO] checking elbaro/zero-mysql against 52995a223f2919dd3e2e427231db90a257350ded for pr-129249-4
[INFO] running `Command { std: "git" "clone" "/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2Felbaro%2Fzero-mysql" "/workspace/builds/worker-3-tc2/source", kill_on_drop: false }`
[INFO] [stderr] Cloning into '/workspace/builds/worker-3-tc2/source'...
[INFO] [stderr] done.
[INFO] started tweaking git repo https://github.com/elbaro/zero-mysql
[INFO] removed 0 missing examples
[INFO] removed 0 missing tests
[INFO] finished tweaking git repo https://github.com/elbaro/zero-mysql
[INFO] tweaked toml for git repo https://github.com/elbaro/zero-mysql written to /workspace/builds/worker-3-tc2/source/Cargo.toml
[INFO] validating manifest of git repo https://github.com/elbaro/zero-mysql on toolchain 52995a223f2919dd3e2e427231db90a257350ded
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+52995a223f2919dd3e2e427231db90a257350ded" "metadata" "--manifest-path" "Cargo.toml" "--no-deps", kill_on_drop: false }`
[INFO] crate git repo https://github.com/elbaro/zero-mysql already has a lockfile, it will not be regenerated
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+52995a223f2919dd3e2e427231db90a257350ded" "fetch" "--manifest-path" "Cargo.toml", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-3-tc2/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-3-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] d986c30a59ab5c5860c62361343af6181b81aea29cd10f7efbbc756f67991f1b
[INFO] running `Command { std: "docker" "start" "d986c30a59ab5c5860c62361343af6181b81aea29cd10f7efbbc756f67991f1b", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "d986c30a59ab5c5860c62361343af6181b81aea29cd10f7efbbc756f67991f1b", 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" "d986c30a59ab5c5860c62361343af6181b81aea29cd10f7efbbc756f67991f1b" "/opt/rustwide/cargo-home/bin/cargo" "+52995a223f2919dd3e2e427231db90a257350ded" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "d986c30a59ab5c5860c62361343af6181b81aea29cd10f7efbbc756f67991f1b", 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" "d986c30a59ab5c5860c62361343af6181b81aea29cd10f7efbbc756f67991f1b" "/opt/rustwide/cargo-home/bin/cargo" "+52995a223f2919dd3e2e427231db90a257350ded" "check" "--frozen" "--all" "--all-targets" "--message-format=json", kill_on_drop: false }`
[INFO] [stderr]    Compiling unicode-ident v1.0.27
[INFO] [stderr]    Compiling libc v0.2.190
[INFO] [stderr]    Compiling find-msvc-tools v0.1.14
[INFO] [stderr]    Compiling crossbeam-utils v0.8.23
[INFO] [stderr]    Compiling num-traits v0.2.19
[INFO] [stderr]    Compiling serde v1.0.229
[INFO] [stderr]    Compiling zerocopy v0.8.63
[INFO] [stderr]     Checking smallvec v1.16.3
[INFO] [stderr]    Compiling proc-macro2 v1.0.107
[INFO] [stderr]    Compiling indexmap v2.14.2
[INFO] [stderr]    Compiling toml_parser v1.1.5+spec-1.1.0
[INFO] [stderr]     Checking crypto-common v0.1.7
[INFO] [stderr]     Checking hybrid-array v0.4.15
[INFO] [stderr]    Compiling crossbeam-epoch v0.9.21
[INFO] [stderr]    Compiling quote v1.0.47
[INFO] [stderr]    Compiling toml_datetime v1.1.2+spec-1.1.0
[INFO] [stderr]     Checking cpufeatures v0.3.1
[INFO] [stderr]    Compiling syn v3.0.9
[INFO] [stderr]    Compiling syn v2.0.119
[INFO] [stderr]    Compiling proc-macro-utils v0.10.0
[INFO] [stderr]     Checking lazy_static v1.5.1
[INFO] [stderr]    Compiling num-integer v0.1.47
[INFO] [stderr]     Checking sharded-slab v0.1.7
[INFO] [stderr]    Compiling toml_edit v0.25.17+spec-1.1.0
[INFO] [stderr]     Checking socket2 v0.6.5
[INFO] [stderr]    Compiling jobserver v0.1.35
[INFO] [stderr]     Checking regex-automata v0.4.18
[INFO] [stderr]    Compiling manyhow-macros v0.11.4
[INFO] [stderr]     Checking hashbrown v0.17.1
[INFO] [stderr]    Compiling cc v1.8.0
[INFO] [stderr]     Checking serde_json v1.0.154
[INFO] [stderr]     Checking digest v0.10.7
[INFO] [stderr]    Compiling object v0.37.3
[INFO] [stderr]    Compiling crossbeam-deque v0.8.8
[INFO] [stderr]     Checking tracing-subscriber v0.3.23
[INFO] [stderr]    Compiling proc-macro-crate v3.5.0
[INFO] [stderr]    Compiling num-bigint v0.4.8
[INFO] [stderr]     Checking mio v1.2.4
[INFO] [stderr]     Checking crypto-common v0.2.2
[INFO] [stderr]    Compiling cmake v0.1.58
[INFO] [stderr]     Checking block-buffer v0.12.1
[INFO] [stderr]    Compiling eyre v0.6.14
[INFO] [stderr]     Checking const-oid v0.10.2
[INFO] [stderr]    Compiling termcolor v1.4.1
[INFO] [stderr]     Checking either v1.19.0
[INFO] [stderr]    Compiling mysql_common v0.37.3
[INFO] [stderr]    Compiling color-spantrace v0.3.0
[INFO] [stderr]     Checking regex v1.13.1
[INFO] [stderr]     Checking gimli v0.32.3
[INFO] [stderr]     Checking bitflags v2.13.2
[INFO] [stderr]     Checking digest v0.11.3
[INFO] [stderr]    Compiling libz-sys v1.1.30
[INFO] [stderr]    Compiling aws-lc-sys v0.46.0
[INFO] [stderr]    Compiling alloca v0.4.0
[INFO] [stderr]     Checking getrandom v0.3.4
[INFO] [stderr]     Checking sha1 v0.10.7
[INFO] [stderr]     Checking flate2 v1.1.10
[INFO] [stderr]     Checking sha2 v0.10.9
[INFO] [stderr]     Checking crossbeam-queue v0.3.14
[INFO] [stderr]     Checking btoi v0.5.0
[INFO] [stderr]     Checking base64 v0.23.1
[INFO] [stderr]     Checking saturating v0.1.0
[INFO] [stderr]     Checking rustc-demangle v0.1.28
[INFO] [stderr]     Checking indenter v0.3.4
[INFO] [stderr]     Checking owo-colors v4.4.0
[INFO] [stderr]     Checking uuid v1.28.0
[INFO] [stderr]    Compiling aws-lc-rs v1.18.2
[INFO] [stderr]     Checking pem v4.0.0
[INFO] [stderr]    Compiling darling_core v0.23.0
[INFO] [stderr]    Compiling manyhow v0.11.4
[INFO] [stderr]     Checking clap_builder v4.6.7
[INFO] [stderr]    Compiling synstructure v0.14.0
[INFO] [stderr]     Checking addr2line v0.25.1
[INFO] [stderr]    Compiling derive_utils v0.16.0
[INFO] [stderr]     Checking rayon-core v1.13.0
[INFO] [stderr]     Checking getrandom v0.4.3
[INFO] [stderr]    Compiling zerocopy-derive v0.8.63
[INFO] [stderr]    Compiling tracing-attributes v0.1.31
[INFO] [stderr]     Checking chacha20 v0.10.2
[INFO] [stderr]     Checking itertools v0.13.0
[INFO] [stderr]    Compiling zerofrom-derive v0.1.8
[INFO] [stderr]    Compiling yoke-derive v0.8.4
[INFO] [stderr]    Compiling zerovec-derive v0.11.6
[INFO] [stderr]    Compiling displaydoc v0.2.7
[INFO] [stderr]    Compiling serde_derive v1.0.229
[INFO] [stderr]    Compiling thiserror-impl v2.0.21
[INFO] [stderr]     Checking zerofrom v0.1.8
[INFO] [stderr]    Compiling darling_macro v0.23.0
[INFO] [stderr]     Checking yoke v0.8.3
[INFO] [stderr]     Checking tracing v0.1.44
[INFO] [stderr]     Checking zerovec v0.11.8
[INFO] [stderr]     Checking zerotrie v0.2.5
[INFO] [stderr]    Compiling darling v0.23.0
[INFO] [stderr]    Compiling tokio-macros v2.7.2
[INFO] [stderr]     Checking tracing-error v0.2.1
[INFO] [stderr]     Checking backtrace v0.3.76
[INFO] [stderr]     Checking tokio v1.53.3
[INFO] [stderr]     Checking tinystr v0.8.4
[INFO] [stderr]     Checking potential_utf v0.1.6
[INFO] [stderr]     Checking icu_collections v2.3.0
[INFO] [stderr]    Compiling futures-macro v0.3.34
[INFO] [stderr]     Checking icu_locale_core v2.3.0
[INFO] [stderr]     Checking thiserror v2.0.21
[INFO] [stderr]    Compiling mysql-common-derive v0.32.2
[INFO] [stderr]     Checking lru v0.18.5
[INFO] [stderr]     Checking cast v0.3.0
[INFO] [stderr]     Checking twox-hash v2.1.5
[INFO] [stderr]    Compiling mysql v28.0.3
[INFO] [stderr]     Checking zeroize v1.9.1
[INFO] [stderr]     Checking futures-util v0.3.34
[INFO] [stderr]     Checking criterion-plot v0.8.2
[INFO] [stderr]     Checking icu_provider v2.3.1
[INFO] [stderr]     Checking color-eyre v0.6.5
[INFO] [stderr]     Checking icu_properties v2.3.0
[INFO] [stderr]     Checking icu_normalizer v2.3.0
[INFO] [stderr]     Checking rand v0.10.3
[INFO] [stderr]    Compiling auto_impl v1.4.0
[INFO] [stderr]    Compiling zero-mysql-derive v0.2.0 (/opt/rustwide/workdir/zero-mysql-derive)
[INFO] [stderr]    Compiling io-enum v1.3.0
[INFO] [stderr]     Checking rayon v1.12.0
[INFO] [stderr]     Checking clap v4.6.7
[INFO] [stderr]     Checking idna_adapter v1.2.2
[INFO] [stderr]     Checking idna v1.1.0
[INFO] [stderr]    Compiling smart-default v0.7.1
[INFO] [stderr]     Checking url v2.5.8
[INFO] [stderr]     Checking tinytemplate v1.2.1
[INFO] [stderr]     Checking keyed_priority_queue v0.4.2
[INFO] [stderr]     Checking plotters v0.3.7
[INFO] [stderr]     Checking sha1 v0.11.0
[INFO] [stderr]     Checking sha2 v0.11.1
[INFO] [stderr]     Checking page_size v0.6.0
[INFO] [stderr]     Checking diff v0.1.13
[INFO] [stderr]     Checking log v0.4.34
[INFO] [stderr]     Checking bufstream v0.1.4
[INFO] [stderr]     Checking yansi v1.0.1
[INFO] [stderr]     Checking oorandom v11.1.5
[INFO] [stderr]     Checking anes v0.1.6
[INFO] [stderr]     Checking pretty_assertions v1.4.1
[INFO] [stderr]     Checking tokio-util v0.7.20
[INFO] [stderr]     Checking half v2.7.1
[INFO] [stderr]     Checking ciborium-ll v0.2.2
[INFO] [stderr]     Checking ciborium v0.2.2
[INFO] [stderr]     Checking criterion v0.8.2
[INFO] [stderr]     Checking mysql_async v0.37.1
[INFO] [stderr]     Checking zero-mysql v0.6.0 (/opt/rustwide/workdir)
[INFO] [stdout] error: useless conversion to the same type: `zero_mysql::error::Error`
[INFO] [stdout]   --> tests/common/check_eq.rs:7:32
[INFO] [stdout]    |
[INFO] [stdout]  2 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  7 |                       return Err(zero_mysql::error::Error::LibraryBug(
[INFO] [stdout]    |  ________________________________^
[INFO] [stdout]  8 | |                         zero_mysql::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  9 | |                     )
[INFO] [stdout] 10 | |                     .into());
[INFO] [stdout]    | |___________________________^
[INFO] [stdout]    |
[INFO] [stdout]   ::: tests/tokio_transaction.rs:64:5
[INFO] [stdout]    |
[INFO] [stdout] 64 |       check_eq!(count_rows(&mut conn, &table).await?, 1);
[INFO] [stdout]    |       -------------------------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<zero_mysql::error::Error as Into<zero_mysql::error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout]    = note: `#[deny(self_type_conversion)]` on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `zero_mysql::error::Error`
[INFO] [stdout]   --> tests/common/check_eq.rs:7:32
[INFO] [stdout]    |
[INFO] [stdout]  2 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  7 |                       return Err(zero_mysql::error::Error::LibraryBug(
[INFO] [stdout]    |  ________________________________^
[INFO] [stdout]  8 | |                         zero_mysql::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  9 | |                     )
[INFO] [stdout] 10 | |                     .into());
[INFO] [stdout]    | |___________________________^
[INFO] [stdout]    |
[INFO] [stdout]   ::: tests/tokio_transaction.rs:84:5
[INFO] [stdout]    |
[INFO] [stdout] 84 |       check_eq!(count_rows(&mut conn, &table).await?, 0);
[INFO] [stdout]    |       -------------------------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<zero_mysql::error::Error as Into<zero_mysql::error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `zero_mysql::error::Error`
[INFO] [stdout]    --> tests/common/check_eq.rs:7:32
[INFO] [stdout]     |
[INFO] [stdout]   2 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]   7 |                       return Err(zero_mysql::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]   8 | |                         zero_mysql::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]   9 | |                     )
[INFO] [stdout]  10 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: tests/tokio_transaction.rs:104:5
[INFO] [stdout]     |
[INFO] [stdout] 104 |       check_eq!(count_rows(&mut conn, &table).await?, 1);
[INFO] [stdout]     |       -------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<zero_mysql::error::Error as Into<zero_mysql::error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `zero_mysql::error::Error`
[INFO] [stdout]    --> tests/common/check_eq.rs:7:32
[INFO] [stdout]     |
[INFO] [stdout]   2 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]   7 |                       return Err(zero_mysql::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]   8 | |                         zero_mysql::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]   9 | |                     )
[INFO] [stdout]  10 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: tests/tokio_transaction.rs:126:5
[INFO] [stdout]     |
[INFO] [stdout] 126 |       check_eq!(count_rows(&mut conn, &table).await?, 0);
[INFO] [stdout]     |       -------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<zero_mysql::error::Error as Into<zero_mysql::error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `zero_mysql::error::Error`
[INFO] [stdout]    --> tests/common/check_eq.rs:7:32
[INFO] [stdout]     |
[INFO] [stdout]   2 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]   7 |                       return Err(zero_mysql::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]   8 | |                         zero_mysql::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]   9 | |                     )
[INFO] [stdout]  10 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: tests/tokio_transaction.rs:147:5
[INFO] [stdout]     |
[INFO] [stdout] 147 |       check_eq!(result, 123);
[INFO] [stdout]     |       ---------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<zero_mysql::error::Error as Into<zero_mysql::error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `zero_mysql::error::Error`
[INFO] [stdout]    --> tests/common/check_eq.rs:7:32
[INFO] [stdout]     |
[INFO] [stdout]   2 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]   7 |                       return Err(zero_mysql::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]   8 | |                         zero_mysql::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]   9 | |                     )
[INFO] [stdout]  10 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: tests/tokio_transaction.rs:148:5
[INFO] [stdout]     |
[INFO] [stdout] 148 |       check_eq!(count_rows(&mut conn, &table).await?, 1);
[INFO] [stdout]     |       -------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<zero_mysql::error::Error as Into<zero_mysql::error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `zero_mysql::error::Error`
[INFO] [stdout]    --> tests/common/check_eq.rs:7:32
[INFO] [stdout]     |
[INFO] [stdout]   2 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]   7 |                       return Err(zero_mysql::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]   8 | |                         zero_mysql::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]   9 | |                     )
[INFO] [stdout]  10 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: tests/tokio_transaction.rs:170:5
[INFO] [stdout]     |
[INFO] [stdout] 170 |       check_eq!(count_rows(&mut conn, &table).await?, 5);
[INFO] [stdout]     |       -------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<zero_mysql::error::Error as Into<zero_mysql::error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `zero_mysql::error::Error`
[INFO] [stdout]    --> tests/common/check_eq.rs:7:32
[INFO] [stdout]     |
[INFO] [stdout]   2 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]   7 |                       return Err(zero_mysql::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]   8 | |                         zero_mysql::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]   9 | |                     )
[INFO] [stdout]  10 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: tests/tokio_transaction.rs:195:5
[INFO] [stdout]     |
[INFO] [stdout] 195 |       check_eq!(count_rows(&mut conn, &table).await?, 0);
[INFO] [stdout]     |       -------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<zero_mysql::error::Error as Into<zero_mysql::error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `zero_mysql::error::Error`
[INFO] [stdout]    --> tests/common/check_eq.rs:7:32
[INFO] [stdout]     |
[INFO] [stdout]   2 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]   7 |                       return Err(zero_mysql::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]   8 | |                         zero_mysql::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]   9 | |                     )
[INFO] [stdout]  10 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: tests/tokio_transaction.rs:224:5
[INFO] [stdout]     |
[INFO] [stdout] 224 |       check_eq!(count_rows(&mut conn, &table).await?, 2);
[INFO] [stdout]     |       -------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<zero_mysql::error::Error as Into<zero_mysql::error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `zero_mysql::error::Error`
[INFO] [stdout]    --> tests/common/check_eq.rs:7:32
[INFO] [stdout]     |
[INFO] [stdout]   2 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]   7 |                       return Err(zero_mysql::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]   8 | |                         zero_mysql::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]   9 | |                     )
[INFO] [stdout]  10 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: tests/tokio_transaction.rs:254:5
[INFO] [stdout]     |
[INFO] [stdout] 254 |       check_eq!(count_rows(&mut conn, &table).await?, 1);
[INFO] [stdout]     |       -------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<zero_mysql::error::Error as Into<zero_mysql::error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `zero_mysql::error::Error`
[INFO] [stdout]    --> tests/common/check.rs:5:24
[INFO] [stdout]     |
[INFO] [stdout]   2 |   macro_rules! check {
[INFO] [stdout] ...
[INFO] [stdout]   5 |               return Err(zero_mysql::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________^
[INFO] [stdout]   6 | |                 zero_mysql::error::eyre!(concat!("check failed: `", stringify!($cond), "`")),
[INFO] [stdout]   7 | |             )
[INFO] [stdout]   8 | |             .into());
[INFO] [stdout]     | |___________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: tests/tokio_transaction.rs:125:5
[INFO] [stdout]     |
[INFO] [stdout] 125 |       check!(result.is_err());
[INFO] [stdout]     |       ----------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<zero_mysql::error::Error as Into<zero_mysql::error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `zero_mysql::error::Error`
[INFO] [stdout]    --> tests/common/check.rs:5:24
[INFO] [stdout]     |
[INFO] [stdout]   2 |   macro_rules! check {
[INFO] [stdout] ...
[INFO] [stdout]   5 |               return Err(zero_mysql::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________^
[INFO] [stdout]   6 | |                 zero_mysql::error::eyre!(concat!("check failed: `", stringify!($cond), "`")),
[INFO] [stdout]   7 | |             )
[INFO] [stdout]   8 | |             .into());
[INFO] [stdout]     | |___________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: tests/tokio_transaction.rs:194:5
[INFO] [stdout]     |
[INFO] [stdout] 194 |       check!(result.is_err());
[INFO] [stdout]     |       ----------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<zero_mysql::error::Error as Into<zero_mysql::error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `zero_mysql::error::Error`
[INFO] [stdout]    --> tests/common/check.rs:5:24
[INFO] [stdout]     |
[INFO] [stdout]   2 |   macro_rules! check {
[INFO] [stdout] ...
[INFO] [stdout]   5 |               return Err(zero_mysql::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________^
[INFO] [stdout]   6 | |                 zero_mysql::error::eyre!(concat!("check failed: `", stringify!($cond), "`")),
[INFO] [stdout]   7 | |             )
[INFO] [stdout]   8 | |             .into());
[INFO] [stdout]     | |___________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: tests/tokio_transaction.rs:265:5
[INFO] [stdout]     |
[INFO] [stdout] 265 |       check!(!conn.in_transaction());
[INFO] [stdout]     |       ------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<zero_mysql::error::Error as Into<zero_mysql::error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `zero_mysql::error::Error`
[INFO] [stdout]    --> tests/common/check.rs:5:24
[INFO] [stdout]     |
[INFO] [stdout]   2 |   macro_rules! check {
[INFO] [stdout] ...
[INFO] [stdout]   5 |               return Err(zero_mysql::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________^
[INFO] [stdout]   6 | |                 zero_mysql::error::eyre!(concat!("check failed: `", stringify!($cond), "`")),
[INFO] [stdout]   7 | |             )
[INFO] [stdout]   8 | |             .into());
[INFO] [stdout]     | |___________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: tests/tokio_transaction.rs:277:5
[INFO] [stdout]     |
[INFO] [stdout] 277 |       check!(!conn.in_transaction());
[INFO] [stdout]     |       ------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<zero_mysql::error::Error as Into<zero_mysql::error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `zero-mysql` (test "tokio_transaction") due to 14 previous errors
[INFO] [stderr] warning: build failed, waiting for other jobs to finish...
[INFO] [stdout] error: useless conversion to the same type: `zero_mysql::error::Error`
[INFO] [stdout]    --> tests/common/check_eq.rs:7:32
[INFO] [stdout]     |
[INFO] [stdout]   2 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]   7 |                       return Err(zero_mysql::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]   8 | |                         zero_mysql::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]   9 | |                     )
[INFO] [stdout]  10 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: tests/temporal_type.rs:107:5
[INFO] [stdout]     |
[INFO] [stdout] 107 |       check_eq!(handler.types.len(), 4);
[INFO] [stdout]     |       --------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<zero_mysql::error::Error as Into<zero_mysql::error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout]     = note: `#[deny(self_type_conversion)]` on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `zero_mysql::error::Error`
[INFO] [stdout]    --> tests/common/check_eq.rs:19:32
[INFO] [stdout]     |
[INFO] [stdout]   2 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  19 |                       return Err(zero_mysql::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  20 | |                         zero_mysql::error::eyre!($($arg)+),
[INFO] [stdout]  21 | |                     )
[INFO] [stdout]  22 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: tests/temporal_type.rs:114:5
[INFO] [stdout]     |
[INFO] [stdout] 114 | /     check_eq!(
[INFO] [stdout] 115 | |         handler.types[0],
[INFO] [stdout] 116 | |         DatetimeType::Datetime0,
[INFO] [stdout] 117 | |         "zero input returns Datetime0"
[INFO] [stdout] 118 | |     );
[INFO] [stdout]     | |_____- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<zero_mysql::error::Error as Into<zero_mysql::error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `zero_mysql::error::Error`
[INFO] [stdout]    --> tests/common/check_eq.rs:19:32
[INFO] [stdout]     |
[INFO] [stdout]   2 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  19 |                       return Err(zero_mysql::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  20 | |                         zero_mysql::error::eyre!($($arg)+),
[INFO] [stdout]  21 | |                     )
[INFO] [stdout]  22 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: tests/temporal_type.rs:122:5
[INFO] [stdout]     |
[INFO] [stdout] 122 | /     check_eq!(
[INFO] [stdout] 123 | |         handler.types[1],
[INFO] [stdout] 124 | |         DatetimeType::Datetime4,
[INFO] [stdout] 125 | |         "ymd input returns Datetime4"
[INFO] [stdout] 126 | |     );
[INFO] [stdout]     | |_____- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<zero_mysql::error::Error as Into<zero_mysql::error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `zero_mysql::error::Error`
[INFO] [stdout]    --> tests/common/check_eq.rs:19:32
[INFO] [stdout]     |
[INFO] [stdout]   2 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  19 |                       return Err(zero_mysql::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  20 | |                         zero_mysql::error::eyre!($($arg)+),
[INFO] [stdout]  21 | |                     )
[INFO] [stdout]  22 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: tests/temporal_type.rs:133:5
[INFO] [stdout]     |
[INFO] [stdout] 133 | /     check_eq!(
[INFO] [stdout] 134 | |         handler.types[2],
[INFO] [stdout] 135 | |         DatetimeType::Datetime7,
[INFO] [stdout] 136 | |         "ymd-hms input returns Datetime7"
[INFO] [stdout] 137 | |     );
[INFO] [stdout]     | |_____- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<zero_mysql::error::Error as Into<zero_mysql::error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `zero_mysql::error::Error`
[INFO] [stdout]    --> tests/common/check_eq.rs:19:32
[INFO] [stdout]     |
[INFO] [stdout]   2 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  19 |                       return Err(zero_mysql::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  20 | |                         zero_mysql::error::eyre!($($arg)+),
[INFO] [stdout]  21 | |                     )
[INFO] [stdout]  22 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: tests/temporal_type.rs:144:5
[INFO] [stdout]     |
[INFO] [stdout] 144 | /     check_eq!(
[INFO] [stdout] 145 | |         handler.types[3],
[INFO] [stdout] 146 | |         DatetimeType::Datetime11,
[INFO] [stdout] 147 | |         "ymd-hms-micro input returns Datetime11"
[INFO] [stdout] 148 | |     );
[INFO] [stdout]     | |_____- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<zero_mysql::error::Error as Into<zero_mysql::error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `zero_mysql::error::Error`
[INFO] [stdout]    --> tests/common/check_eq.rs:7:32
[INFO] [stdout]     |
[INFO] [stdout]   2 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]   7 |                       return Err(zero_mysql::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]   8 | |                         zero_mysql::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]   9 | |                     )
[INFO] [stdout]  10 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: tests/temporal_type.rs:183:5
[INFO] [stdout]     |
[INFO] [stdout] 183 |       check_eq!(handler.types.len(), 4);
[INFO] [stdout]     |       --------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<zero_mysql::error::Error as Into<zero_mysql::error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `zero_mysql::error::Error`
[INFO] [stdout]    --> tests/common/check_eq.rs:19:32
[INFO] [stdout]     |
[INFO] [stdout]   2 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  19 |                       return Err(zero_mysql::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  20 | |                         zero_mysql::error::eyre!($($arg)+),
[INFO] [stdout]  21 | |                     )
[INFO] [stdout]  22 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: tests/temporal_type.rs:190:5
[INFO] [stdout]     |
[INFO] [stdout] 190 | /     check_eq!(
[INFO] [stdout] 191 | |         handler.types[0],
[INFO] [stdout] 192 | |         DatetimeType::Datetime0,
[INFO] [stdout] 193 | |         "zero input returns Datetime0"
[INFO] [stdout] 194 | |     );
[INFO] [stdout]     | |_____- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<zero_mysql::error::Error as Into<zero_mysql::error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `zero_mysql::error::Error`
[INFO] [stdout]    --> tests/common/check_eq.rs:19:32
[INFO] [stdout]     |
[INFO] [stdout]   2 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  19 |                       return Err(zero_mysql::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  20 | |                         zero_mysql::error::eyre!($($arg)+),
[INFO] [stdout]  21 | |                     )
[INFO] [stdout]  22 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: tests/temporal_type.rs:201:5
[INFO] [stdout]     |
[INFO] [stdout] 201 | /     check_eq!(
[INFO] [stdout] 202 | |         handler.types[1],
[INFO] [stdout] 203 | |         DatetimeType::Datetime4,
[INFO] [stdout] 204 | |         "ymd input returns Datetime4"
[INFO] [stdout] 205 | |     );
[INFO] [stdout]     | |_____- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<zero_mysql::error::Error as Into<zero_mysql::error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `zero_mysql::error::Error`
[INFO] [stdout]    --> tests/common/check_eq.rs:19:32
[INFO] [stdout]     |
[INFO] [stdout]   2 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  19 |                       return Err(zero_mysql::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  20 | |                         zero_mysql::error::eyre!($($arg)+),
[INFO] [stdout]  21 | |                     )
[INFO] [stdout]  22 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: tests/temporal_type.rs:212:5
[INFO] [stdout]     |
[INFO] [stdout] 212 | /     check_eq!(
[INFO] [stdout] 213 | |         handler.types[2],
[INFO] [stdout] 214 | |         DatetimeType::Datetime7,
[INFO] [stdout] 215 | |         "ymd-hms input returns Datetime7"
[INFO] [stdout] 216 | |     );
[INFO] [stdout]     | |_____- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<zero_mysql::error::Error as Into<zero_mysql::error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `zero_mysql::error::Error`
[INFO] [stdout]    --> tests/common/check_eq.rs:19:32
[INFO] [stdout]     |
[INFO] [stdout]   2 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  19 |                       return Err(zero_mysql::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  20 | |                         zero_mysql::error::eyre!($($arg)+),
[INFO] [stdout]  21 | |                     )
[INFO] [stdout]  22 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: tests/temporal_type.rs:223:5
[INFO] [stdout]     |
[INFO] [stdout] 223 | /     check_eq!(
[INFO] [stdout] 224 | |         handler.types[3],
[INFO] [stdout] 225 | |         DatetimeType::Datetime11,
[INFO] [stdout] 226 | |         "ymd-hms-micro input returns Datetime11"
[INFO] [stdout] 227 | |     );
[INFO] [stdout]     | |_____- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<zero_mysql::error::Error as Into<zero_mysql::error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `zero_mysql::error::Error`
[INFO] [stdout]   --> tests/common/check_eq.rs:7:32
[INFO] [stdout]    |
[INFO] [stdout]  2 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  7 |                       return Err(zero_mysql::error::Error::LibraryBug(
[INFO] [stdout]    |  ________________________________^
[INFO] [stdout]  8 | |                         zero_mysql::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  9 | |                     )
[INFO] [stdout] 10 | |                     .into());
[INFO] [stdout]    | |___________________________^
[INFO] [stdout]    |
[INFO] [stdout]   ::: tests/derive.rs:94:5
[INFO] [stdout]    |
[INFO] [stdout] 94 |       check_eq!(users.len(), 2);
[INFO] [stdout]    |       ------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<zero_mysql::error::Error as Into<zero_mysql::error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout]    = note: `#[deny(self_type_conversion)]` on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `zero_mysql::error::Error`
[INFO] [stdout]    --> tests/common/check_eq.rs:7:32
[INFO] [stdout]     |
[INFO] [stdout]   2 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]   7 |                       return Err(zero_mysql::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]   8 | |                         zero_mysql::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]   9 | |                     )
[INFO] [stdout]  10 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: tests/derive.rs:95:5
[INFO] [stdout]     |
[INFO] [stdout]  95 | /     check_eq!(
[INFO] [stdout]  96 | |         users[0],
[INFO] [stdout]  97 | |         User {
[INFO] [stdout]  98 | |             id: 1,
[INFO] [stdout] ...   |
[INFO] [stdout] 102 | |     );
[INFO] [stdout]     | |_____- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<zero_mysql::error::Error as Into<zero_mysql::error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `zero_mysql::error::Error`
[INFO] [stdout]    --> tests/common/check_eq.rs:7:32
[INFO] [stdout]     |
[INFO] [stdout]   2 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]   7 |                       return Err(zero_mysql::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]   8 | |                         zero_mysql::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]   9 | |                     )
[INFO] [stdout]  10 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: tests/derive.rs:103:5
[INFO] [stdout]     |
[INFO] [stdout] 103 | /     check_eq!(
[INFO] [stdout] 104 | |         users[1],
[INFO] [stdout] 105 | |         User {
[INFO] [stdout] 106 | |             id: 2,
[INFO] [stdout] ...   |
[INFO] [stdout] 110 | |     );
[INFO] [stdout]     | |_____- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<zero_mysql::error::Error as Into<zero_mysql::error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `zero_mysql::error::Error`
[INFO] [stdout]    --> tests/common/check_eq.rs:7:32
[INFO] [stdout]     |
[INFO] [stdout]   2 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]   7 |                       return Err(zero_mysql::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]   8 | |                         zero_mysql::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]   9 | |                     )
[INFO] [stdout]  10 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: tests/derive.rs:135:5
[INFO] [stdout]     |
[INFO] [stdout] 135 | /     check_eq!(
[INFO] [stdout] 136 | |         user,
[INFO] [stdout] 137 | |         Some(User {
[INFO] [stdout] 138 | |             id: 1,
[INFO] [stdout] ...   |
[INFO] [stdout] 141 | |         })
[INFO] [stdout] 142 | |     );
[INFO] [stdout]     | |_____- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<zero_mysql::error::Error as Into<zero_mysql::error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `zero_mysql::error::Error`
[INFO] [stdout]    --> tests/common/check_eq.rs:7:32
[INFO] [stdout]     |
[INFO] [stdout]   2 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]   7 |                       return Err(zero_mysql::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]   8 | |                         zero_mysql::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]   9 | |                     )
[INFO] [stdout]  10 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: tests/derive.rs:145:5
[INFO] [stdout]     |
[INFO] [stdout] 145 |       check_eq!(user2, None);
[INFO] [stdout]     |       ---------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<zero_mysql::error::Error as Into<zero_mysql::error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `zero_mysql::error::Error`
[INFO] [stdout]    --> tests/common/check_eq.rs:7:32
[INFO] [stdout]     |
[INFO] [stdout]   2 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]   7 |                       return Err(zero_mysql::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]   8 | |                         zero_mysql::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]   9 | |                     )
[INFO] [stdout]  10 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: tests/derive.rs:176:5
[INFO] [stdout]     |
[INFO] [stdout] 176 |       check_eq!(names, vec!["Alice", "Bob"]);
[INFO] [stdout]     |       -------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<zero_mysql::error::Error as Into<zero_mysql::error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `zero_mysql::error::Error`
[INFO] [stdout]    --> tests/common/check_eq.rs:7:32
[INFO] [stdout]     |
[INFO] [stdout]   2 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]   7 |                       return Err(zero_mysql::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]   8 | |                         zero_mysql::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]   9 | |                     )
[INFO] [stdout]  10 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: tests/derive.rs:202:5
[INFO] [stdout]     |
[INFO] [stdout] 202 |       check_eq!(users[0].email, Some("alice@example.com".to_string()));
[INFO] [stdout]     |       ---------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<zero_mysql::error::Error as Into<zero_mysql::error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `zero_mysql::error::Error`
[INFO] [stdout]    --> tests/common/check_eq.rs:7:32
[INFO] [stdout]     |
[INFO] [stdout]   2 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]   7 |                       return Err(zero_mysql::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]   8 | |                         zero_mysql::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]   9 | |                     )
[INFO] [stdout]  10 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: tests/derive.rs:203:5
[INFO] [stdout]     |
[INFO] [stdout] 203 |       check_eq!(users[1].email, None);
[INFO] [stdout]     |       ------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<zero_mysql::error::Error as Into<zero_mysql::error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `zero_mysql::error::Error`
[INFO] [stdout]    --> tests/common/check_eq.rs:7:32
[INFO] [stdout]     |
[INFO] [stdout]   2 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]   7 |                       return Err(zero_mysql::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]   8 | |                         zero_mysql::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]   9 | |                     )
[INFO] [stdout]  10 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: tests/derive.rs:231:5
[INFO] [stdout]     |
[INFO] [stdout] 231 |       check_eq!(users.len(), 1);
[INFO] [stdout]     |       ------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<zero_mysql::error::Error as Into<zero_mysql::error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `zero_mysql::error::Error`
[INFO] [stdout]    --> tests/common/check_eq.rs:7:32
[INFO] [stdout]     |
[INFO] [stdout]   2 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]   7 |                       return Err(zero_mysql::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]   8 | |                         zero_mysql::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]   9 | |                     )
[INFO] [stdout]  10 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: tests/derive.rs:232:5
[INFO] [stdout]     |
[INFO] [stdout] 232 |       check_eq!(users[0].name, "Alice");
[INFO] [stdout]     |       --------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<zero_mysql::error::Error as Into<zero_mysql::error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `zero_mysql::error::Error`
[INFO] [stdout]    --> tests/common/check_eq.rs:7:32
[INFO] [stdout]     |
[INFO] [stdout]   2 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]   7 |                       return Err(zero_mysql::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]   8 | |                         zero_mysql::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]   9 | |                     )
[INFO] [stdout]  10 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: tests/derive.rs:310:5
[INFO] [stdout]     |
[INFO] [stdout] 310 | /     check_eq!(
[INFO] [stdout] 311 | |         users[0],
[INFO] [stdout] 312 | |         User {
[INFO] [stdout] 313 | |             id: 1,
[INFO] [stdout] ...   |
[INFO] [stdout] 317 | |     );
[INFO] [stdout]     | |_____- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<zero_mysql::error::Error as Into<zero_mysql::error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `zero_mysql::error::Error`
[INFO] [stdout]    --> tests/common/check_eq.rs:7:32
[INFO] [stdout]     |
[INFO] [stdout]   2 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]   7 |                       return Err(zero_mysql::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]   8 | |                         zero_mysql::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]   9 | |                     )
[INFO] [stdout]  10 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: tests/derive.rs:343:5
[INFO] [stdout]     |
[INFO] [stdout] 343 | /     check_eq!(
[INFO] [stdout] 344 | |         rows[0],
[INFO] [stdout] 345 | |         IntTypes {
[INFO] [stdout] 346 | |             tiny: -1,
[INFO] [stdout] ...   |
[INFO] [stdout] 351 | |     );
[INFO] [stdout]     | |_____- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<zero_mysql::error::Error as Into<zero_mysql::error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `zero_mysql::error::Error`
[INFO] [stdout]    --> tests/common/check_err.rs:7:28
[INFO] [stdout]     |
[INFO] [stdout]   2 |   macro_rules! check_err {
[INFO] [stdout] ...
[INFO] [stdout]   7 |                   return Err(zero_mysql::error::Error::LibraryBug(
[INFO] [stdout]     |  ____________________________^
[INFO] [stdout]   8 | |                     zero_mysql::error::eyre!(concat!(
[INFO] [stdout]   9 | |                         "expected Err: `",
[INFO] [stdout]  10 | |                         stringify!($result),
[INFO] [stdout] ...   |
[INFO] [stdout]  14 | |                 .into());
[INFO] [stdout]     | |_______________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: tests/derive.rs:258:15
[INFO] [stdout]     |
[INFO] [stdout] 258 |       let err = check_err!(result);
[INFO] [stdout]     |                 ------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<zero_mysql::error::Error as Into<zero_mysql::error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `zero_mysql::error::Error`
[INFO] [stdout]    --> tests/common/check_err.rs:7:28
[INFO] [stdout]     |
[INFO] [stdout]   2 |   macro_rules! check_err {
[INFO] [stdout] ...
[INFO] [stdout]   7 |                   return Err(zero_mysql::error::Error::LibraryBug(
[INFO] [stdout]     |  ____________________________^
[INFO] [stdout]   8 | |                     zero_mysql::error::eyre!(concat!(
[INFO] [stdout]   9 | |                         "expected Err: `",
[INFO] [stdout]  10 | |                         stringify!($result),
[INFO] [stdout] ...   |
[INFO] [stdout]  14 | |                 .into());
[INFO] [stdout]     | |_______________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: tests/derive.rs:283:15
[INFO] [stdout]     |
[INFO] [stdout] 283 |       let err = check_err!(result);
[INFO] [stdout]     |                 ------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<zero_mysql::error::Error as Into<zero_mysql::error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `zero_mysql::error::Error`
[INFO] [stdout]    --> tests/common/check.rs:5:24
[INFO] [stdout]     |
[INFO] [stdout]   2 |   macro_rules! check {
[INFO] [stdout] ...
[INFO] [stdout]   5 |               return Err(zero_mysql::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________^
[INFO] [stdout]   6 | |                 zero_mysql::error::eyre!(concat!("check failed: `", stringify!($cond), "`")),
[INFO] [stdout]   7 | |             )
[INFO] [stdout]   8 | |             .into());
[INFO] [stdout]     | |___________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: tests/derive.rs:259:5
[INFO] [stdout]     |
[INFO] [stdout] 259 |       check!(err.to_string().contains("Unknown column"));
[INFO] [stdout]     |       -------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<zero_mysql::error::Error as Into<zero_mysql::error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `zero-mysql` (test "temporal_type") due to 10 previous errors
[INFO] [stdout] error: useless conversion to the same type: `zero_mysql::error::Error`
[INFO] [stdout]    --> tests/common/check.rs:5:24
[INFO] [stdout]     |
[INFO] [stdout]   2 |   macro_rules! check {
[INFO] [stdout] ...
[INFO] [stdout]   5 |               return Err(zero_mysql::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________^
[INFO] [stdout]   6 | |                 zero_mysql::error::eyre!(concat!("check failed: `", stringify!($cond), "`")),
[INFO] [stdout]   7 | |             )
[INFO] [stdout]   8 | |             .into());
[INFO] [stdout]     | |___________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: tests/derive.rs:284:5
[INFO] [stdout]     |
[INFO] [stdout] 284 |       check!(err.to_string().contains("Missing column"));
[INFO] [stdout]     |       -------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<zero_mysql::error::Error as Into<zero_mysql::error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `zero_mysql::error::Error`
[INFO] [stdout]    --> tests/common/check.rs:5:24
[INFO] [stdout]     |
[INFO] [stdout]   2 |   macro_rules! check {
[INFO] [stdout] ...
[INFO] [stdout]   5 |               return Err(zero_mysql::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________^
[INFO] [stdout]   6 | |                 zero_mysql::error::eyre!(concat!("check failed: `", stringify!($cond), "`")),
[INFO] [stdout]   7 | |             )
[INFO] [stdout]   8 | |             .into());
[INFO] [stdout]     | |___________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: tests/derive.rs:376:5
[INFO] [stdout]     |
[INFO] [stdout] 376 |       check!(close1);
[INFO] [stdout]     |       -------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<zero_mysql::error::Error as Into<zero_mysql::error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `zero_mysql::error::Error`
[INFO] [stdout]    --> tests/common/check.rs:5:24
[INFO] [stdout]     |
[INFO] [stdout]   2 |   macro_rules! check {
[INFO] [stdout] ...
[INFO] [stdout]   5 |               return Err(zero_mysql::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________^
[INFO] [stdout]   6 | |                 zero_mysql::error::eyre!(concat!("check failed: `", stringify!($cond), "`")),
[INFO] [stdout]   7 | |             )
[INFO] [stdout]   8 | |             .into());
[INFO] [stdout]     | |___________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: tests/derive.rs:378:5
[INFO] [stdout]     |
[INFO] [stdout] 378 |       check!(close2);
[INFO] [stdout]     |       -------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<zero_mysql::error::Error as Into<zero_mysql::error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `zero-mysql` (test "derive") due to 18 previous errors
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> src/test_macros.rs:27:32
[INFO] [stdout]    |
[INFO] [stdout] 22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout] 27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]    |  ________________________________^
[INFO] [stdout] 28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout] 29 | |                     )
[INFO] [stdout] 30 | |                     .into());
[INFO] [stdout]    | |___________________________^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/protocol/command/column_definition_test.rs:34:5
[INFO] [stdout]    |
[INFO] [stdout] 34 |       check_eq!(tail.charset(), 33);
[INFO] [stdout]    |       ----------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout]    = note: `#[deny(self_type_conversion)]` on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> src/test_macros.rs:27:32
[INFO] [stdout]    |
[INFO] [stdout] 22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout] 27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]    |  ________________________________^
[INFO] [stdout] 28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout] 29 | |                     )
[INFO] [stdout] 30 | |                     .into());
[INFO] [stdout]    | |___________________________^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/protocol/command/column_definition_test.rs:35:5
[INFO] [stdout]    |
[INFO] [stdout] 35 |       check_eq!(tail.column_length(), 255);
[INFO] [stdout]    |       ------------------------------------ in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> src/test_macros.rs:27:32
[INFO] [stdout]    |
[INFO] [stdout] 22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout] 27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]    |  ________________________________^
[INFO] [stdout] 28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout] 29 | |                     )
[INFO] [stdout] 30 | |                     .into());
[INFO] [stdout]    | |___________________________^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/protocol/command/column_definition_test.rs:41:5
[INFO] [stdout]    |
[INFO] [stdout] 41 |       check_eq!(col_type, ColumnType::MYSQL_TYPE_VAR_STRING);
[INFO] [stdout]    |       ------------------------------------------------------ in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> src/test_macros.rs:27:32
[INFO] [stdout]    |
[INFO] [stdout] 22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout] 27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]    |  ________________________________^
[INFO] [stdout] 28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout] 29 | |                     )
[INFO] [stdout] 30 | |                     .into());
[INFO] [stdout]    | |___________________________^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/protocol/command/column_definition_test.rs:65:5
[INFO] [stdout]    |
[INFO] [stdout] 65 |       check_eq!(col_type, ColumnType::MYSQL_TYPE_TINY);
[INFO] [stdout]    |       ------------------------------------------------ in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> src/test_macros.rs:27:32
[INFO] [stdout]    |
[INFO] [stdout] 22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout] 27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]    |  ________________________________^
[INFO] [stdout] 28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout] 29 | |                     )
[INFO] [stdout] 30 | |                     .into());
[INFO] [stdout]    | |___________________________^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/protocol/command/column_definition_test.rs:84:5
[INFO] [stdout]    |
[INFO] [stdout] 84 |       check_eq!(tail.charset(), 63);
[INFO] [stdout]    |       ----------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> src/test_macros.rs:27:32
[INFO] [stdout]    |
[INFO] [stdout] 22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout] 27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]    |  ________________________________^
[INFO] [stdout] 28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout] 29 | |                     )
[INFO] [stdout] 30 | |                     .into());
[INFO] [stdout]    | |___________________________^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/protocol/command/column_definition_test.rs:85:5
[INFO] [stdout]    |
[INFO] [stdout] 85 |       check_eq!(tail.column_length(), 11);
[INFO] [stdout]    |       ----------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> src/test_macros.rs:27:32
[INFO] [stdout]    |
[INFO] [stdout] 22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout] 27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]    |  ________________________________^
[INFO] [stdout] 28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout] 29 | |                     )
[INFO] [stdout] 30 | |                     .into());
[INFO] [stdout]    | |___________________________^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/protocol/command/column_definition_test.rs:94:5
[INFO] [stdout]    |
[INFO] [stdout] 94 |       check_eq!(col_type, ColumnType::MYSQL_TYPE_LONG);
[INFO] [stdout]    |       ------------------------------------------------ in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/protocol/command/column_definition_test.rs:134:5
[INFO] [stdout]     |
[INFO] [stdout] 134 |       check_eq!(tail.charset(), 33);
[INFO] [stdout]     |       ----------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/protocol/command/column_definition_test.rs:135:5
[INFO] [stdout]     |
[INFO] [stdout] 135 |       check_eq!(tail.column_length(), 255);
[INFO] [stdout]     |       ------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/protocol/command/column_definition_test.rs:142:5
[INFO] [stdout]     |
[INFO] [stdout] 142 |       check_eq!(col_type, ColumnType::MYSQL_TYPE_TINY);
[INFO] [stdout]     |       ------------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/protocol/command/column_definition_test.rs:203:5
[INFO] [stdout]     |
[INFO] [stdout] 203 |       check_eq!(col_def.schema, b"test");
[INFO] [stdout]     |       ---------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/protocol/command/column_definition_test.rs:204:5
[INFO] [stdout]     |
[INFO] [stdout] 204 |       check_eq!(col_def.table_alias, b"users");
[INFO] [stdout]     |       ---------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/protocol/command/column_definition_test.rs:205:5
[INFO] [stdout]     |
[INFO] [stdout] 205 |       check_eq!(col_def.table_original, b"users");
[INFO] [stdout]     |       ------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/protocol/command/column_definition_test.rs:206:5
[INFO] [stdout]     |
[INFO] [stdout] 206 |       check_eq!(col_def.name_alias, b"id");
[INFO] [stdout]     |       ------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/protocol/command/column_definition_test.rs:207:5
[INFO] [stdout]     |
[INFO] [stdout] 207 |       check_eq!(col_def.name_original, b"id");
[INFO] [stdout]     |       --------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/protocol/command/column_definition_test.rs:210:5
[INFO] [stdout]     |
[INFO] [stdout] 210 |       check_eq!(col_def.tail.charset(), 33);
[INFO] [stdout]     |       ------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/protocol/command/column_definition_test.rs:211:5
[INFO] [stdout]     |
[INFO] [stdout] 211 |       check_eq!(col_def.tail.column_length(), 11);
[INFO] [stdout]     |       ------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/protocol/command/column_definition_test.rs:218:5
[INFO] [stdout]     |
[INFO] [stdout] 218 |       check_eq!(col_type, ColumnType::MYSQL_TYPE_LONG);
[INFO] [stdout]     |       ------------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/protocol/connection/handshake.rs:874:9
[INFO] [stdout]     |
[INFO] [stdout] 874 | /         check_eq!(
[INFO] [stdout] 875 | |             read_caching_sha2_password_fast_auth_result(&[0x03])?,
[INFO] [stdout] 876 | |             CachingSha2PasswordFastAuthResult::Success,
[INFO] [stdout] 877 | |         );
[INFO] [stdout]     | |_________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/protocol/connection/handshake.rs:878:9
[INFO] [stdout]     |
[INFO] [stdout] 878 | /         check_eq!(
[INFO] [stdout] 879 | |             read_caching_sha2_password_fast_auth_result(&[0x04])?,
[INFO] [stdout] 880 | |             CachingSha2PasswordFastAuthResult::FullAuthRequired,
[INFO] [stdout] 881 | |         );
[INFO] [stdout]     | |_________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/protocol/connection/handshake.rs:952:9
[INFO] [stdout]     |
[INFO] [stdout] 952 |           check_eq!(handshake.mariadb_capabilities.bits(), known);
[INFO] [stdout]     |           ------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> src/test_macros.rs:27:32
[INFO] [stdout]    |
[INFO] [stdout] 22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout] 27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]    |  ________________________________^
[INFO] [stdout] 28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout] 29 | |                     )
[INFO] [stdout] 30 | |                     .into());
[INFO] [stdout]    | |___________________________^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/protocol/trait/param_test.rs:14:5
[INFO] [stdout]    |
[INFO] [stdout] 14 |       check_eq!(types, vec![ColumnType::MYSQL_TYPE_LONG as u8, 0x00]);
[INFO] [stdout]    |       --------------------------------------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> src/test_macros.rs:27:32
[INFO] [stdout]    |
[INFO] [stdout] 22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout] 27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]    |  ________________________________^
[INFO] [stdout] 28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout] 29 | |                     )
[INFO] [stdout] 30 | |                     .into());
[INFO] [stdout]    | |___________________________^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/protocol/trait/param_test.rs:15:5
[INFO] [stdout]    |
[INFO] [stdout] 15 |       check_eq!(values, (-42i32).to_le_bytes());
[INFO] [stdout]    |       ----------------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> src/test_macros.rs:27:32
[INFO] [stdout]    |
[INFO] [stdout] 22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout] 27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]    |  ________________________________^
[INFO] [stdout] 28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout] 29 | |                     )
[INFO] [stdout] 30 | |                     .into());
[INFO] [stdout]    | |___________________________^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/protocol/trait/param_test.rs:29:5
[INFO] [stdout]    |
[INFO] [stdout] 29 |       check_eq!(types, vec![ColumnType::MYSQL_TYPE_LONGLONG as u8, 0x80]);
[INFO] [stdout]    |       ------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> src/test_macros.rs:27:32
[INFO] [stdout]    |
[INFO] [stdout] 22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout] 27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]    |  ________________________________^
[INFO] [stdout] 28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout] 29 | |                     )
[INFO] [stdout] 30 | |                     .into());
[INFO] [stdout]    | |___________________________^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/protocol/trait/param_test.rs:30:5
[INFO] [stdout]    |
[INFO] [stdout] 30 |       check_eq!(values, 12345678901234u64.to_le_bytes());
[INFO] [stdout]    |       -------------------------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> src/test_macros.rs:27:32
[INFO] [stdout]    |
[INFO] [stdout] 22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout] 27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]    |  ________________________________^
[INFO] [stdout] 28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout] 29 | |                     )
[INFO] [stdout] 30 | |                     .into());
[INFO] [stdout]    | |___________________________^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/protocol/trait/param_test.rs:43:5
[INFO] [stdout]    |
[INFO] [stdout] 43 |       check_eq!(types, vec![ColumnType::MYSQL_TYPE_DOUBLE as u8, 0x00]);
[INFO] [stdout]    |       ----------------------------------------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> src/test_macros.rs:27:32
[INFO] [stdout]    |
[INFO] [stdout] 22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout] 27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]    |  ________________________________^
[INFO] [stdout] 28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout] 29 | |                     )
[INFO] [stdout] 30 | |                     .into());
[INFO] [stdout]    | |___________________________^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/protocol/trait/param_test.rs:44:5
[INFO] [stdout]    |
[INFO] [stdout] 44 |       check_eq!(values, 3.12159f64.to_bits().to_le_bytes());
[INFO] [stdout]    |       ----------------------------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> src/test_macros.rs:27:32
[INFO] [stdout]    |
[INFO] [stdout] 22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout] 27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]    |  ________________________________^
[INFO] [stdout] 28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout] 29 | |                     )
[INFO] [stdout] 30 | |                     .into());
[INFO] [stdout]    | |___________________________^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/protocol/trait/param_test.rs:57:5
[INFO] [stdout]    |
[INFO] [stdout] 57 |       check_eq!(types, vec![ColumnType::MYSQL_TYPE_VAR_STRING as u8, 0x00]);
[INFO] [stdout]    |       --------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> src/test_macros.rs:27:32
[INFO] [stdout]    |
[INFO] [stdout] 22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout] 27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]    |  ________________________________^
[INFO] [stdout] 28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout] 29 | |                     )
[INFO] [stdout] 30 | |                     .into());
[INFO] [stdout]    | |___________________________^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/protocol/trait/param_test.rs:58:5
[INFO] [stdout]    |
[INFO] [stdout] 58 |       check_eq!(values[0], 13);
[INFO] [stdout]    |       ------------------------ in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> src/test_macros.rs:27:32
[INFO] [stdout]    |
[INFO] [stdout] 22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout] 27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]    |  ________________________________^
[INFO] [stdout] 28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout] 29 | |                     )
[INFO] [stdout] 30 | |                     .into());
[INFO] [stdout]    | |___________________________^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/protocol/trait/param_test.rs:59:5
[INFO] [stdout]    |
[INFO] [stdout] 59 |       check_eq!(&values[1..], b"Hello, MySQL!");
[INFO] [stdout]    |       ----------------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> src/test_macros.rs:27:32
[INFO] [stdout]    |
[INFO] [stdout] 22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout] 27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]    |  ________________________________^
[INFO] [stdout] 28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout] 29 | |                     )
[INFO] [stdout] 30 | |                     .into());
[INFO] [stdout]    | |___________________________^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/protocol/trait/param_test.rs:72:5
[INFO] [stdout]    |
[INFO] [stdout] 72 |       check_eq!(types, vec![ColumnType::MYSQL_TYPE_VAR_STRING as u8, 0x00]);
[INFO] [stdout]    |       --------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> src/test_macros.rs:27:32
[INFO] [stdout]    |
[INFO] [stdout] 22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout] 27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]    |  ________________________________^
[INFO] [stdout] 28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout] 29 | |                     )
[INFO] [stdout] 30 | |                     .into());
[INFO] [stdout]    | |___________________________^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/protocol/trait/param_test.rs:73:5
[INFO] [stdout]    |
[INFO] [stdout] 73 |       check_eq!(values[0], 4);
[INFO] [stdout]    |       ----------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> src/test_macros.rs:27:32
[INFO] [stdout]    |
[INFO] [stdout] 22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout] 27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]    |  ________________________________^
[INFO] [stdout] 28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout] 29 | |                     )
[INFO] [stdout] 30 | |                     .into());
[INFO] [stdout]    | |___________________________^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/protocol/trait/param_test.rs:74:5
[INFO] [stdout]    |
[INFO] [stdout] 74 |       check_eq!(&values[1..], b"Rust");
[INFO] [stdout]    |       -------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> src/test_macros.rs:27:32
[INFO] [stdout]    |
[INFO] [stdout] 22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout] 27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]    |  ________________________________^
[INFO] [stdout] 28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout] 29 | |                     )
[INFO] [stdout] 30 | |                     .into());
[INFO] [stdout]    | |___________________________^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/protocol/trait/param_test.rs:87:5
[INFO] [stdout]    |
[INFO] [stdout] 87 |       check_eq!(types, vec![ColumnType::MYSQL_TYPE_BLOB as u8, 0x00]);
[INFO] [stdout]    |       --------------------------------------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> src/test_macros.rs:27:32
[INFO] [stdout]    |
[INFO] [stdout] 22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout] 27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]    |  ________________________________^
[INFO] [stdout] 28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout] 29 | |                     )
[INFO] [stdout] 30 | |                     .into());
[INFO] [stdout]    | |___________________________^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/protocol/trait/param_test.rs:88:5
[INFO] [stdout]    |
[INFO] [stdout] 88 |       check_eq!(values[0], 4);
[INFO] [stdout]    |       ----------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> src/test_macros.rs:27:32
[INFO] [stdout]    |
[INFO] [stdout] 22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout] 27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]    |  ________________________________^
[INFO] [stdout] 28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout] 29 | |                     )
[INFO] [stdout] 30 | |                     .into());
[INFO] [stdout]    | |___________________________^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/protocol/trait/param_test.rs:89:5
[INFO] [stdout]    |
[INFO] [stdout] 89 |       check_eq!(&values[1..], &[0xDE, 0xAD, 0xBE, 0xEF]);
[INFO] [stdout]    |       -------------------------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/protocol/trait/param_test.rs:102:5
[INFO] [stdout]     |
[INFO] [stdout] 102 |       check_eq!(types, vec![ColumnType::MYSQL_TYPE_BLOB as u8, 0x00]);
[INFO] [stdout]     |       --------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/protocol/trait/param_test.rs:103:5
[INFO] [stdout]     |
[INFO] [stdout] 103 |       check_eq!(values[0], 5);
[INFO] [stdout]     |       ----------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/protocol/trait/param_test.rs:104:5
[INFO] [stdout]     |
[INFO] [stdout] 104 |       check_eq!(&values[1..], &[1, 2, 3, 4, 5]);
[INFO] [stdout]     |       ----------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/protocol/trait/param_test.rs:118:5
[INFO] [stdout]     |
[INFO] [stdout] 118 |       check_eq!(types, vec![ColumnType::MYSQL_TYPE_LONG as u8, 0x00]);
[INFO] [stdout]     |       --------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/protocol/trait/param_test.rs:119:5
[INFO] [stdout]     |
[INFO] [stdout] 119 |       check_eq!(values, 42i32.to_le_bytes());
[INFO] [stdout]     |       -------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/protocol/trait/param_test.rs:133:5
[INFO] [stdout]     |
[INFO] [stdout] 133 |       check_eq!(types, vec![ColumnType::MYSQL_TYPE_LONG as u8, 0x00]);
[INFO] [stdout]     |       --------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/protocol/trait/param_test.rs:134:5
[INFO] [stdout]     |
[INFO] [stdout] 134 |       check_eq!(values, Vec::<u8>::new());
[INFO] [stdout]     |       ----------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/protocol/trait/param_test.rs:147:5
[INFO] [stdout]     |
[INFO] [stdout] 147 |       check_eq!(types, vec![ColumnType::MYSQL_TYPE_VAR_STRING as u8, 0x00]);
[INFO] [stdout]     |       --------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/protocol/trait/param_test.rs:148:5
[INFO] [stdout]     |
[INFO] [stdout] 148 |       check_eq!(values[0], 4);
[INFO] [stdout]     |       ----------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/protocol/trait/param_test.rs:149:5
[INFO] [stdout]     |
[INFO] [stdout] 149 |       check_eq!(&values[1..], b"test");
[INFO] [stdout]     |       -------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/protocol/trait/param_test.rs:160:5
[INFO] [stdout]     |
[INFO] [stdout] 160 |       check_eq!(Params::len(&params), 3);
[INFO] [stdout]     |       ---------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/protocol/trait/param_test.rs:164:5
[INFO] [stdout]     |
[INFO] [stdout] 164 |       check_eq!(null_bitmap, vec![0]);
[INFO] [stdout]     |       ------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/protocol/trait/param_test.rs:168:5
[INFO] [stdout]     |
[INFO] [stdout] 168 |       check_eq!(types.len(), 6);
[INFO] [stdout]     |       ------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/protocol/trait/param_test.rs:179:5
[INFO] [stdout]     |
[INFO] [stdout] 179 |       check_eq!(Params::len(&params), 3);
[INFO] [stdout]     |       ---------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/protocol/trait/param_test.rs:183:5
[INFO] [stdout]     |
[INFO] [stdout] 183 |       check_eq!(null_bitmap, vec![0b00000010]);
[INFO] [stdout]     |       ---------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/protocol/trait/param_test.rs:187:5
[INFO] [stdout]     |
[INFO] [stdout] 187 |       check_eq!(values.len(), 9);
[INFO] [stdout]     |       -------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/protocol/trait/param_test.rs:196:5
[INFO] [stdout]     |
[INFO] [stdout] 196 |       check_eq!(Params::len(&params), 11);
[INFO] [stdout]     |       ----------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/protocol/trait/param_test.rs:200:5
[INFO] [stdout]     |
[INFO] [stdout] 200 |       check_eq!(types.len(), 22);
[INFO] [stdout]     |       -------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/protocol/trait/param_test.rs:204:5
[INFO] [stdout]     |
[INFO] [stdout] 204 |       check_eq!(values.len(), 48);
[INFO] [stdout]     |       --------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/protocol/trait/param_test.rs:215:5
[INFO] [stdout]     |
[INFO] [stdout] 215 |       check_eq!(Params::len(&params), 3);
[INFO] [stdout]     |       ---------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/protocol/trait/param_test.rs:219:5
[INFO] [stdout]     |
[INFO] [stdout] 219 |       check_eq!(values.len(), 17);
[INFO] [stdout]     |       --------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/protocol/trait/param_test.rs:230:5
[INFO] [stdout]     |
[INFO] [stdout] 230 |       check_eq!(Params::len(&params), 3);
[INFO] [stdout]     |       ---------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/protocol/trait/param_test.rs:234:5
[INFO] [stdout]     |
[INFO] [stdout] 234 |       check_eq!(out.len(), 11);
[INFO] [stdout]     |       ------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/protocol/trait/param_test.rs:245:5
[INFO] [stdout]     |
[INFO] [stdout] 245 |       check_eq!(Params::len(&values), 3);
[INFO] [stdout]     |       ---------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/protocol/trait/param_test.rs:249:5
[INFO] [stdout]     |
[INFO] [stdout] 249 |       check_eq!(null_bitmap, vec![0]);
[INFO] [stdout]     |       ------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/protocol/trait/param_test.rs:253:5
[INFO] [stdout]     |
[INFO] [stdout] 253 |       check_eq!(types.len(), 6); // 3 params * 2 bytes
[INFO] [stdout]     |       ------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/protocol/trait/param_test.rs:257:5
[INFO] [stdout]     |
[INFO] [stdout] 257 |       check_eq!(out.len(), 12); // 3 * 4 bytes for i32
[INFO] [stdout]     |       ------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/protocol/trait/param_test.rs:264:5
[INFO] [stdout]     |
[INFO] [stdout] 264 |       check_eq!(Params::len(&values), 3);
[INFO] [stdout]     |       ---------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/protocol/trait/param_test.rs:268:5
[INFO] [stdout]     |
[INFO] [stdout] 268 |       check_eq!(types.len(), 6);
[INFO] [stdout]     |       ------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/protocol/trait/param_test.rs:272:5
[INFO] [stdout]     |
[INFO] [stdout] 272 |       check_eq!(out.len(), 12);
[INFO] [stdout]     |       ------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/protocol/trait/param_test.rs:290:5
[INFO] [stdout]     |
[INFO] [stdout] 290 |       check_eq!(Params::len(&values), 3);
[INFO] [stdout]     |       ---------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/protocol/trait/param_test.rs:294:5
[INFO] [stdout]     |
[INFO] [stdout] 294 |       check_eq!(null_bitmap, vec![0b00000010]); // bit 1 set for None
[INFO] [stdout]     |       ---------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/protocol/trait/param_test.rs:298:5
[INFO] [stdout]     |
[INFO] [stdout] 298 |       check_eq!(out.len(), 8); // 2 * 4 bytes (None is skipped)
[INFO] [stdout]     |       ----------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/protocol/trait/param_test.rs:319:5
[INFO] [stdout]     |
[INFO] [stdout] 319 |       check_eq!(Params::len(&values), 2);
[INFO] [stdout]     |       ---------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/protocol/trait/param_test.rs:323:5
[INFO] [stdout]     |
[INFO] [stdout] 323 |       check_eq!(types.len(), 4); // 2 params * 2 bytes
[INFO] [stdout]     |       ------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/protocol/trait/param_test.rs:328:5
[INFO] [stdout]     |
[INFO] [stdout] 328 |       check_eq!(out.len(), 12);
[INFO] [stdout]     |       ------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> src/test_macros.rs:27:32
[INFO] [stdout]    |
[INFO] [stdout] 22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout] 27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]    |  ________________________________^
[INFO] [stdout] 28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout] 29 | |                     )
[INFO] [stdout] 30 | |                     .into());
[INFO] [stdout]    | |___________________________^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/opts_test.rs:11:5
[INFO] [stdout]    |
[INFO] [stdout] 11 |       check_eq!(opts.port, 3306);
[INFO] [stdout]    |       -------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> src/test_macros.rs:27:32
[INFO] [stdout]    |
[INFO] [stdout] 22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout] 27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]    |  ________________________________^
[INFO] [stdout] 28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout] 29 | |                     )
[INFO] [stdout] 30 | |                     .into());
[INFO] [stdout]    | |___________________________^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/opts_test.rs:15:5
[INFO] [stdout]    |
[INFO] [stdout] 15 |       check_eq!(opts.tls_mode, TlsMode::Prefer);
[INFO] [stdout]    |       ----------------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> src/test_macros.rs:27:32
[INFO] [stdout]    |
[INFO] [stdout] 22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout] 27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]    |  ________________________________^
[INFO] [stdout] 28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout] 29 | |                     )
[INFO] [stdout] 30 | |                     .into());
[INFO] [stdout]    | |___________________________^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/opts_test.rs:19:5
[INFO] [stdout]    |
[INFO] [stdout] 19 |       check_eq!(opts.pool_max_idle_conn, 100);
[INFO] [stdout]    |       --------------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> src/test_macros.rs:27:32
[INFO] [stdout]    |
[INFO] [stdout] 22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout] 27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]    |  ________________________________^
[INFO] [stdout] 28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout] 29 | |                     )
[INFO] [stdout] 30 | |                     .into());
[INFO] [stdout]    | |___________________________^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/opts_test.rs:27:5
[INFO] [stdout]    |
[INFO] [stdout] 27 |       check_eq!(opts.host, "localhost");
[INFO] [stdout]    |       --------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> src/test_macros.rs:27:32
[INFO] [stdout]    |
[INFO] [stdout] 22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout] 27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]    |  ________________________________^
[INFO] [stdout] 28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout] 29 | |                     )
[INFO] [stdout] 30 | |                     .into());
[INFO] [stdout]    | |___________________________^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/opts_test.rs:28:5
[INFO] [stdout]    |
[INFO] [stdout] 28 |       check_eq!(opts.port, 3306);
[INFO] [stdout]    |       -------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> src/test_macros.rs:27:32
[INFO] [stdout]    |
[INFO] [stdout] 22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout] 27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]    |  ________________________________^
[INFO] [stdout] 28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout] 29 | |                     )
[INFO] [stdout] 30 | |                     .into());
[INFO] [stdout]    | |___________________________^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/opts_test.rs:38:5
[INFO] [stdout]    |
[INFO] [stdout] 38 |       check_eq!(opts.host, "localhost");
[INFO] [stdout]    |       --------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> src/test_macros.rs:27:32
[INFO] [stdout]    |
[INFO] [stdout] 22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout] 27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]    |  ________________________________^
[INFO] [stdout] 28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout] 29 | |                     )
[INFO] [stdout] 30 | |                     .into());
[INFO] [stdout]    | |___________________________^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/opts_test.rs:39:5
[INFO] [stdout]    |
[INFO] [stdout] 39 |       check_eq!(opts.port, 3307);
[INFO] [stdout]    |       -------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> src/test_macros.rs:27:32
[INFO] [stdout]    |
[INFO] [stdout] 22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout] 27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]    |  ________________________________^
[INFO] [stdout] 28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout] 29 | |                     )
[INFO] [stdout] 30 | |                     .into());
[INFO] [stdout]    | |___________________________^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/opts_test.rs:46:5
[INFO] [stdout]    |
[INFO] [stdout] 46 |       check_eq!(opts.host, "localhost");
[INFO] [stdout]    |       --------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> src/test_macros.rs:27:32
[INFO] [stdout]    |
[INFO] [stdout] 22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout] 27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]    |  ________________________________^
[INFO] [stdout] 28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout] 29 | |                     )
[INFO] [stdout] 30 | |                     .into());
[INFO] [stdout]    | |___________________________^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/opts_test.rs:47:5
[INFO] [stdout]    |
[INFO] [stdout] 47 |       check_eq!(opts.user, "root");
[INFO] [stdout]    |       ---------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> src/test_macros.rs:27:32
[INFO] [stdout]    |
[INFO] [stdout] 22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout] 27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]    |  ________________________________^
[INFO] [stdout] 28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout] 29 | |                     )
[INFO] [stdout] 30 | |                     .into());
[INFO] [stdout]    | |___________________________^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/opts_test.rs:48:5
[INFO] [stdout]    |
[INFO] [stdout] 48 |       check_eq!(opts.password.as_str(), "password");
[INFO] [stdout]    |       --------------------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> src/test_macros.rs:27:32
[INFO] [stdout]    |
[INFO] [stdout] 22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout] 27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]    |  ________________________________^
[INFO] [stdout] 28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout] 29 | |                     )
[INFO] [stdout] 30 | |                     .into());
[INFO] [stdout]    | |___________________________^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/opts_test.rs:55:5
[INFO] [stdout]    |
[INFO] [stdout] 55 |       check_eq!(opts.host, "localhost");
[INFO] [stdout]    |       --------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> src/test_macros.rs:27:32
[INFO] [stdout]    |
[INFO] [stdout] 22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout] 27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]    |  ________________________________^
[INFO] [stdout] 28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout] 29 | |                     )
[INFO] [stdout] 30 | |                     .into());
[INFO] [stdout]    | |___________________________^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/opts_test.rs:56:5
[INFO] [stdout]    |
[INFO] [stdout] 56 |       check_eq!(opts.db.as_deref(), Some("mydb"));
[INFO] [stdout]    |       ------------------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> src/test_macros.rs:27:32
[INFO] [stdout]    |
[INFO] [stdout] 22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout] 27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]    |  ________________________________^
[INFO] [stdout] 28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout] 29 | |                     )
[INFO] [stdout] 30 | |                     .into());
[INFO] [stdout]    | |___________________________^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/opts_test.rs:70:5
[INFO] [stdout]    |
[INFO] [stdout] 70 |       check_eq!(opts.host, "db.example.com");
[INFO] [stdout]    |       -------------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> src/test_macros.rs:27:32
[INFO] [stdout]    |
[INFO] [stdout] 22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout] 27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]    |  ________________________________^
[INFO] [stdout] 28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout] 29 | |                     )
[INFO] [stdout] 30 | |                     .into());
[INFO] [stdout]    | |___________________________^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/opts_test.rs:71:5
[INFO] [stdout]    |
[INFO] [stdout] 71 |       check_eq!(opts.port, 3308);
[INFO] [stdout]    |       -------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> src/test_macros.rs:27:32
[INFO] [stdout]    |
[INFO] [stdout] 22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout] 27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]    |  ________________________________^
[INFO] [stdout] 28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout] 29 | |                     )
[INFO] [stdout] 30 | |                     .into());
[INFO] [stdout]    | |___________________________^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/opts_test.rs:72:5
[INFO] [stdout]    |
[INFO] [stdout] 72 |       check_eq!(opts.user, "admin");
[INFO] [stdout]    |       ----------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> src/test_macros.rs:27:32
[INFO] [stdout]    |
[INFO] [stdout] 22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout] 27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]    |  ________________________________^
[INFO] [stdout] 28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout] 29 | |                     )
[INFO] [stdout] 30 | |                     .into());
[INFO] [stdout]    | |___________________________^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/opts_test.rs:73:5
[INFO] [stdout]    |
[INFO] [stdout] 73 |       check_eq!(opts.password.as_str(), "secret");
[INFO] [stdout]    |       ------------------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> src/test_macros.rs:27:32
[INFO] [stdout]    |
[INFO] [stdout] 22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout] 27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]    |  ________________________________^
[INFO] [stdout] 28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout] 29 | |                     )
[INFO] [stdout] 30 | |                     .into());
[INFO] [stdout]    | |___________________________^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/opts_test.rs:74:5
[INFO] [stdout]    |
[INFO] [stdout] 74 |       check_eq!(opts.db.as_deref(), Some("production"));
[INFO] [stdout]    |       ------------------------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> src/test_macros.rs:27:32
[INFO] [stdout]    |
[INFO] [stdout] 22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout] 27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]    |  ________________________________^
[INFO] [stdout] 28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout] 29 | |                     )
[INFO] [stdout] 30 | |                     .into());
[INFO] [stdout]    | |___________________________^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/opts_test.rs:81:5
[INFO] [stdout]    |
[INFO] [stdout] 81 |       check_eq!(opts.socket.as_deref(), Some("/var/run/mysqld/mysqld.sock"));
[INFO] [stdout]    |       ---------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> src/test_macros.rs:27:32
[INFO] [stdout]    |
[INFO] [stdout] 22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout] 27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]    |  ________________________________^
[INFO] [stdout] 28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout] 29 | |                     )
[INFO] [stdout] 30 | |                     .into());
[INFO] [stdout]    | |___________________________^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/opts_test.rs:88:5
[INFO] [stdout]    |
[INFO] [stdout] 88 |       check_eq!(opts1.tls_mode, TlsMode::Disable);
[INFO] [stdout]    |       ------------------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> src/test_macros.rs:27:32
[INFO] [stdout]    |
[INFO] [stdout] 22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout] 27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]    |  ________________________________^
[INFO] [stdout] 28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout] 29 | |                     )
[INFO] [stdout] 30 | |                     .into());
[INFO] [stdout]    | |___________________________^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/opts_test.rs:91:5
[INFO] [stdout]    |
[INFO] [stdout] 91 |       check_eq!(opts2.tls_mode, TlsMode::Prefer);
[INFO] [stdout]    |       ------------------------------------------ in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> src/test_macros.rs:27:32
[INFO] [stdout]    |
[INFO] [stdout] 22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout] 27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]    |  ________________________________^
[INFO] [stdout] 28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout] 29 | |                     )
[INFO] [stdout] 30 | |                     .into());
[INFO] [stdout]    | |___________________________^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/opts_test.rs:94:5
[INFO] [stdout]    |
[INFO] [stdout] 94 |       check_eq!(opts3.tls_mode, TlsMode::Require);
[INFO] [stdout]    |       ------------------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/opts_test.rs:138:5
[INFO] [stdout]     |
[INFO] [stdout] 138 |       check_eq!(opts.init_command.as_deref(), Some("SET NAMES utf8mb4"));
[INFO] [stdout]     |       ------------------------------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/opts_test.rs:155:5
[INFO] [stdout]     |
[INFO] [stdout] 155 |       check_eq!(opts1.pool_max_idle_conn, 50);
[INFO] [stdout]     |       --------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/opts_test.rs:158:5
[INFO] [stdout]     |
[INFO] [stdout] 158 |       check_eq!(opts2.pool_max_idle_conn, 0);
[INFO] [stdout]     |       -------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/opts_test.rs:165:5
[INFO] [stdout]     |
[INFO] [stdout] 165 |       check_eq!(opts.pool_max_concurrency, Some(10));
[INFO] [stdout]     |       ---------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/opts_test.rs:174:5
[INFO] [stdout]     |
[INFO] [stdout] 174 |       check_eq!(opts.host, "localhost");
[INFO] [stdout]     |       --------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/opts_test.rs:175:5
[INFO] [stdout]     |
[INFO] [stdout] 175 |       check_eq!(opts.port, 3307);
[INFO] [stdout]     |       -------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/opts_test.rs:176:5
[INFO] [stdout]     |
[INFO] [stdout] 176 |       check_eq!(opts.user, "root");
[INFO] [stdout]     |       ---------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/opts_test.rs:177:5
[INFO] [stdout]     |
[INFO] [stdout] 177 |       check_eq!(opts.password.as_str(), "pass");
[INFO] [stdout]     |       ----------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/opts_test.rs:178:5
[INFO] [stdout]     |
[INFO] [stdout] 178 |       check_eq!(opts.db.as_deref(), Some("mydb"));
[INFO] [stdout]     |       ------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/opts_test.rs:179:5
[INFO] [stdout]     |
[INFO] [stdout] 179 |       check_eq!(opts.tls_mode, TlsMode::Require);
[INFO] [stdout]     |       ------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/opts_test.rs:181:5
[INFO] [stdout]     |
[INFO] [stdout] 181 |       check_eq!(opts.pool_max_idle_conn, 50);
[INFO] [stdout]     |       -------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/opts_test.rs:235:5
[INFO] [stdout]     |
[INFO] [stdout] 235 |       check_eq!(opts.host, "127.0.0.1");
[INFO] [stdout]     |       --------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/opts_test.rs:236:5
[INFO] [stdout]     |
[INFO] [stdout] 236 |       check_eq!(opts.port, 3306);
[INFO] [stdout]     |       -------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/opts_test.rs:243:5
[INFO] [stdout]     |
[INFO] [stdout] 243 |       check_eq!(opts.host, "[::1]");
[INFO] [stdout]     |       ----------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/opts_test.rs:244:5
[INFO] [stdout]     |
[INFO] [stdout] 244 |       check_eq!(opts.port, 3306);
[INFO] [stdout]     |       -------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/opts_test.rs:251:5
[INFO] [stdout]     |
[INFO] [stdout] 251 |       check_eq!(opts.password.as_str(), "p@ssw/rd");
[INFO] [stdout]     |       --------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/opts_test.rs:258:5
[INFO] [stdout]     |
[INFO] [stdout] 258 |       check_eq!(opts.user, "al@ice");
[INFO] [stdout]     |       ------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/opts_test.rs:259:5
[INFO] [stdout]     |
[INFO] [stdout] 259 |       check_eq!(opts.db.as_deref(), Some("my db"));
[INFO] [stdout]     |       -------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/opts_test.rs:266:5
[INFO] [stdout]     |
[INFO] [stdout] 266 |       check_eq!(opts.password.as_str(), "p@ss");
[INFO] [stdout]     |       ----------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/opts_test.rs:267:5
[INFO] [stdout]     |
[INFO] [stdout] 267 |       check_eq!(opts.host, "localhost");
[INFO] [stdout]     |       --------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/opts_test.rs:282:5
[INFO] [stdout]     |
[INFO] [stdout] 282 |       check_eq!(opts.user, "root");
[INFO] [stdout]     |       ---------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/opts_test.rs:290:5
[INFO] [stdout]     |
[INFO] [stdout] 290 |       check_eq!(opts.user, "root");
[INFO] [stdout]     |       ---------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> src/test_macros.rs:27:32
[INFO] [stdout]    |
[INFO] [stdout] 22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout] 27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]    |  ________________________________^
[INFO] [stdout] 28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout] 29 | |                     )
[INFO] [stdout] 30 | |                     .into());
[INFO] [stdout]    | |___________________________^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/value_test.rs:32:5
[INFO] [stdout]    |
[INFO] [stdout] 32 |       check_eq!(rest.len(), 0);
[INFO] [stdout]    |       ------------------------ in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> src/test_macros.rs:27:32
[INFO] [stdout]    |
[INFO] [stdout] 22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout] 27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]    |  ________________________________^
[INFO] [stdout] 28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout] 29 | |                     )
[INFO] [stdout] 30 | |                     .into());
[INFO] [stdout]    | |___________________________^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/value_test.rs:39:5
[INFO] [stdout]    |
[INFO] [stdout] 39 |       check_eq!(rest2.len(), 0);
[INFO] [stdout]    |       ------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> src/test_macros.rs:27:32
[INFO] [stdout]    |
[INFO] [stdout] 22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout] 27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]    |  ________________________________^
[INFO] [stdout] 28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout] 29 | |                     )
[INFO] [stdout] 30 | |                     .into());
[INFO] [stdout]    | |___________________________^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/value_test.rs:46:5
[INFO] [stdout]    |
[INFO] [stdout] 46 |       check_eq!(rest3.len(), 0);
[INFO] [stdout]    |       ------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> src/test_macros.rs:27:32
[INFO] [stdout]    |
[INFO] [stdout] 22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout] 27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]    |  ________________________________^
[INFO] [stdout] 28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout] 29 | |                     )
[INFO] [stdout] 30 | |                     .into());
[INFO] [stdout]    | |___________________________^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/value_test.rs:58:5
[INFO] [stdout]    |
[INFO] [stdout] 58 |       check_eq!(rest.len(), 0);
[INFO] [stdout]    |       ------------------------ in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> src/test_macros.rs:27:32
[INFO] [stdout]    |
[INFO] [stdout] 22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout] 27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]    |  ________________________________^
[INFO] [stdout] 28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout] 29 | |                     )
[INFO] [stdout] 30 | |                     .into());
[INFO] [stdout]    | |___________________________^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/value_test.rs:65:5
[INFO] [stdout]    |
[INFO] [stdout] 65 |       check_eq!(rest2.len(), 0);
[INFO] [stdout]    |       ------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> src/test_macros.rs:27:32
[INFO] [stdout]    |
[INFO] [stdout] 22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout] 27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]    |  ________________________________^
[INFO] [stdout] 28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout] 29 | |                     )
[INFO] [stdout] 30 | |                     .into());
[INFO] [stdout]    | |___________________________^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/value_test.rs:83:5
[INFO] [stdout]    |
[INFO] [stdout] 83 |       check_eq!(rest.len(), 0);
[INFO] [stdout]    |       ------------------------ in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> src/test_macros.rs:27:32
[INFO] [stdout]    |
[INFO] [stdout] 22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout] 27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]    |  ________________________________^
[INFO] [stdout] 28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout] 29 | |                     )
[INFO] [stdout] 30 | |                     .into());
[INFO] [stdout]    | |___________________________^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/value_test.rs:96:5
[INFO] [stdout]    |
[INFO] [stdout] 96 |       check_eq!(rest2.len(), 0);
[INFO] [stdout]    |       ------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/value_test.rs:109:5
[INFO] [stdout]     |
[INFO] [stdout] 109 |       check_eq!(rest.len(), 0);
[INFO] [stdout]     |       ------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/value_test.rs:122:5
[INFO] [stdout]     |
[INFO] [stdout] 122 |       check_eq!(ts.year(), 2024);
[INFO] [stdout]     |       -------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/value_test.rs:123:5
[INFO] [stdout]     |
[INFO] [stdout] 123 |       check_eq!(ts.month, 12);
[INFO] [stdout]     |       ----------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/value_test.rs:124:5
[INFO] [stdout]     |
[INFO] [stdout] 124 |       check_eq!(ts.day, 25);
[INFO] [stdout]     |       --------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/value_test.rs:125:5
[INFO] [stdout]     |
[INFO] [stdout] 125 |       check_eq!(rest2.len(), 0);
[INFO] [stdout]     |       ------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/value_test.rs:141:5
[INFO] [stdout]     |
[INFO] [stdout] 141 |       check_eq!(ts2.year(), 2024);
[INFO] [stdout]     |       --------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/value_test.rs:142:5
[INFO] [stdout]     |
[INFO] [stdout] 142 |       check_eq!(ts2.month, 12);
[INFO] [stdout]     |       ------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/value_test.rs:143:5
[INFO] [stdout]     |
[INFO] [stdout] 143 |       check_eq!(ts2.day, 25);
[INFO] [stdout]     |       ---------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/value_test.rs:144:5
[INFO] [stdout]     |
[INFO] [stdout] 144 |       check_eq!(ts2.hour, 15);
[INFO] [stdout]     |       ----------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/value_test.rs:145:5
[INFO] [stdout]     |
[INFO] [stdout] 145 |       check_eq!(ts2.minute, 30);
[INFO] [stdout]     |       ------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/value_test.rs:146:5
[INFO] [stdout]     |
[INFO] [stdout] 146 |       check_eq!(ts2.second, 45);
[INFO] [stdout]     |       ------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/value_test.rs:147:5
[INFO] [stdout]     |
[INFO] [stdout] 147 |       check_eq!(rest3.len(), 0);
[INFO] [stdout]     |       ------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/value_test.rs:160:5
[INFO] [stdout]     |
[INFO] [stdout] 160 |       check_eq!(rest.len(), 0);
[INFO] [stdout]     |       ------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/value_test.rs:174:5
[INFO] [stdout]     |
[INFO] [stdout] 174 |       check_eq!(ts.year(), 2024);
[INFO] [stdout]     |       -------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/value_test.rs:175:5
[INFO] [stdout]     |
[INFO] [stdout] 175 |       check_eq!(ts.month, 12);
[INFO] [stdout]     |       ----------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/value_test.rs:176:5
[INFO] [stdout]     |
[INFO] [stdout] 176 |       check_eq!(ts.day, 25);
[INFO] [stdout]     |       --------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/value_test.rs:177:5
[INFO] [stdout]     |
[INFO] [stdout] 177 |       check_eq!(rest2.len(), 0);
[INFO] [stdout]     |       ------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/value_test.rs:190:5
[INFO] [stdout]     |
[INFO] [stdout] 190 |       check_eq!(rest.len(), 0);
[INFO] [stdout]     |       ------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/value_test.rs:206:5
[INFO] [stdout]     |
[INFO] [stdout] 206 |       check_eq!(time.days(), 1);
[INFO] [stdout]     |       ------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/value_test.rs:207:5
[INFO] [stdout]     |
[INFO] [stdout] 207 |       check_eq!(time.hour, 12);
[INFO] [stdout]     |       ------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/value_test.rs:208:5
[INFO] [stdout]     |
[INFO] [stdout] 208 |       check_eq!(time.minute, 30);
[INFO] [stdout]     |       -------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/value_test.rs:209:5
[INFO] [stdout]     |
[INFO] [stdout] 209 |       check_eq!(time.second, 45);
[INFO] [stdout]     |       -------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/value_test.rs:210:5
[INFO] [stdout]     |
[INFO] [stdout] 210 |       check_eq!(rest2.len(), 0);
[INFO] [stdout]     |       ------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/value_test.rs:228:5
[INFO] [stdout]     |
[INFO] [stdout] 228 |       check_eq!(bytes, b"Hello");
[INFO] [stdout]     |       -------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/value_test.rs:229:5
[INFO] [stdout]     |
[INFO] [stdout] 229 |       check_eq!(rest.len(), 0);
[INFO] [stdout]     |       ------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/value_test.rs:247:5
[INFO] [stdout]     |
[INFO] [stdout] 247 |       check_eq!(bytes, &[0xDE, 0xAD, 0xBE, 0xEF]);
[INFO] [stdout]     |       ------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/value_test.rs:248:5
[INFO] [stdout]     |
[INFO] [stdout] 248 |       check_eq!(rest.len(), 0);
[INFO] [stdout]     |       ------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/value_test.rs:260:5
[INFO] [stdout]     |
[INFO] [stdout] 260 |       check_eq!(rest.len(), 0);
[INFO] [stdout]     |       ------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:27:32
[INFO] [stdout]     |
[INFO] [stdout]  22 |   macro_rules! check_eq {
[INFO] [stdout] ...
[INFO] [stdout]  27 |                       return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________________^
[INFO] [stdout]  28 | |                         $crate::error::eyre!("{:?} != {:?}", left_val, right_val),
[INFO] [stdout]  29 | |                     )
[INFO] [stdout]  30 | |                     .into());
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/value_test.rs:272:5
[INFO] [stdout]     |
[INFO] [stdout] 272 |       check_eq!(rest, &[0xFF, 0xFF]);
[INFO] [stdout]     |       ------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> src/test_macros.rs:5:24
[INFO] [stdout]    |
[INFO] [stdout]  2 |   macro_rules! check {
[INFO] [stdout] ...
[INFO] [stdout]  5 |               return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]    |  ________________________^
[INFO] [stdout]  6 | |                 $crate::error::eyre!(concat!("check failed: `", stringify!($cond), "`")),
[INFO] [stdout]  7 | |             )
[INFO] [stdout]  8 | |             .into());
[INFO] [stdout]    | |___________________^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/protocol/command/column_definition_test.rs:38:5
[INFO] [stdout]    |
[INFO] [stdout] 38 |       check!(flags.is_empty());
[INFO] [stdout]    |       ------------------------ in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> src/test_macros.rs:5:24
[INFO] [stdout]    |
[INFO] [stdout]  2 |   macro_rules! check {
[INFO] [stdout] ...
[INFO] [stdout]  5 |               return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]    |  ________________________^
[INFO] [stdout]  6 | |                 $crate::error::eyre!(concat!("check failed: `", stringify!($cond), "`")),
[INFO] [stdout]  7 | |             )
[INFO] [stdout]  8 | |             .into());
[INFO] [stdout]    | |___________________^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/protocol/command/column_definition_test.rs:60:5
[INFO] [stdout]    |
[INFO] [stdout] 60 |       check!(flags.contains(ColumnFlags::NOT_NULL_FLAG));
[INFO] [stdout]    |       -------------------------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> src/test_macros.rs:5:24
[INFO] [stdout]    |
[INFO] [stdout]  2 |   macro_rules! check {
[INFO] [stdout] ...
[INFO] [stdout]  5 |               return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]    |  ________________________^
[INFO] [stdout]  6 | |                 $crate::error::eyre!(concat!("check failed: `", stringify!($cond), "`")),
[INFO] [stdout]  7 | |             )
[INFO] [stdout]  8 | |             .into());
[INFO] [stdout]    | |___________________^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/protocol/command/column_definition_test.rs:61:5
[INFO] [stdout]    |
[INFO] [stdout] 61 |       check!(flags.contains(ColumnFlags::UNSIGNED_FLAG));
[INFO] [stdout]    |       -------------------------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> src/test_macros.rs:5:24
[INFO] [stdout]    |
[INFO] [stdout]  2 |   macro_rules! check {
[INFO] [stdout] ...
[INFO] [stdout]  5 |               return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]    |  ________________________^
[INFO] [stdout]  6 | |                 $crate::error::eyre!(concat!("check failed: `", stringify!($cond), "`")),
[INFO] [stdout]  7 | |             )
[INFO] [stdout]  8 | |             .into());
[INFO] [stdout]    | |___________________^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/protocol/command/column_definition_test.rs:62:5
[INFO] [stdout]    |
[INFO] [stdout] 62 |       check!(!flags.contains(ColumnFlags::AUTO_INCREMENT_FLAG));
[INFO] [stdout]    |       --------------------------------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> src/test_macros.rs:5:24
[INFO] [stdout]    |
[INFO] [stdout]  2 |   macro_rules! check {
[INFO] [stdout] ...
[INFO] [stdout]  5 |               return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]    |  ________________________^
[INFO] [stdout]  6 | |                 $crate::error::eyre!(concat!("check failed: `", stringify!($cond), "`")),
[INFO] [stdout]  7 | |             )
[INFO] [stdout]  8 | |             .into());
[INFO] [stdout]    | |___________________^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/protocol/command/column_definition_test.rs:88:5
[INFO] [stdout]    |
[INFO] [stdout] 88 |       check!(flags.contains(ColumnFlags::NOT_NULL_FLAG));
[INFO] [stdout]    |       -------------------------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> src/test_macros.rs:5:24
[INFO] [stdout]    |
[INFO] [stdout]  2 |   macro_rules! check {
[INFO] [stdout] ...
[INFO] [stdout]  5 |               return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]    |  ________________________^
[INFO] [stdout]  6 | |                 $crate::error::eyre!(concat!("check failed: `", stringify!($cond), "`")),
[INFO] [stdout]  7 | |             )
[INFO] [stdout]  8 | |             .into());
[INFO] [stdout]    | |___________________^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/protocol/command/column_definition_test.rs:89:5
[INFO] [stdout]    |
[INFO] [stdout] 89 |       check!(flags.contains(ColumnFlags::PRI_KEY_FLAG));
[INFO] [stdout]    |       ------------------------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> src/test_macros.rs:5:24
[INFO] [stdout]    |
[INFO] [stdout]  2 |   macro_rules! check {
[INFO] [stdout] ...
[INFO] [stdout]  5 |               return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]    |  ________________________^
[INFO] [stdout]  6 | |                 $crate::error::eyre!(concat!("check failed: `", stringify!($cond), "`")),
[INFO] [stdout]  7 | |             )
[INFO] [stdout]  8 | |             .into());
[INFO] [stdout]    | |___________________^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/protocol/command/column_definition_test.rs:90:5
[INFO] [stdout]    |
[INFO] [stdout] 90 |       check!(flags.contains(ColumnFlags::AUTO_INCREMENT_FLAG));
[INFO] [stdout]    |       -------------------------------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> src/test_macros.rs:5:24
[INFO] [stdout]    |
[INFO] [stdout]  2 |   macro_rules! check {
[INFO] [stdout] ...
[INFO] [stdout]  5 |               return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]    |  ________________________^
[INFO] [stdout]  6 | |                 $crate::error::eyre!(concat!("check failed: `", stringify!($cond), "`")),
[INFO] [stdout]  7 | |             )
[INFO] [stdout]  8 | |             .into());
[INFO] [stdout]    | |___________________^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/protocol/command/column_definition_test.rs:91:5
[INFO] [stdout]    |
[INFO] [stdout] 91 |       check!(flags.contains(ColumnFlags::PART_KEY_FLAG));
[INFO] [stdout]    |       -------------------------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:5:24
[INFO] [stdout]     |
[INFO] [stdout]   2 |   macro_rules! check {
[INFO] [stdout] ...
[INFO] [stdout]   5 |               return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________^
[INFO] [stdout]   6 | |                 $crate::error::eyre!(concat!("check failed: `", stringify!($cond), "`")),
[INFO] [stdout]   7 | |             )
[INFO] [stdout]   8 | |             .into());
[INFO] [stdout]     | |___________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/protocol/command/column_definition_test.rs:138:5
[INFO] [stdout]     |
[INFO] [stdout] 138 |       check!(flags.contains(ColumnFlags::NOT_NULL_FLAG));
[INFO] [stdout]     |       -------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:5:24
[INFO] [stdout]     |
[INFO] [stdout]   2 |   macro_rules! check {
[INFO] [stdout] ...
[INFO] [stdout]   5 |               return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________^
[INFO] [stdout]   6 | |                 $crate::error::eyre!(concat!("check failed: `", stringify!($cond), "`")),
[INFO] [stdout]   7 | |             )
[INFO] [stdout]   8 | |             .into());
[INFO] [stdout]     | |___________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/protocol/command/column_definition_test.rs:139:5
[INFO] [stdout]     |
[INFO] [stdout] 139 |       check!(flags.contains(ColumnFlags::UNSIGNED_FLAG));
[INFO] [stdout]     |       -------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:5:24
[INFO] [stdout]     |
[INFO] [stdout]   2 |   macro_rules! check {
[INFO] [stdout] ...
[INFO] [stdout]   5 |               return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________^
[INFO] [stdout]   6 | |                 $crate::error::eyre!(concat!("check failed: `", stringify!($cond), "`")),
[INFO] [stdout]   7 | |             )
[INFO] [stdout]   8 | |             .into());
[INFO] [stdout]     | |___________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/protocol/command/column_definition_test.rs:214:5
[INFO] [stdout]     |
[INFO] [stdout] 214 |       check!(flags.contains(ColumnFlags::NOT_NULL_FLAG));
[INFO] [stdout]     |       -------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:5:24
[INFO] [stdout]     |
[INFO] [stdout]   2 |   macro_rules! check {
[INFO] [stdout] ...
[INFO] [stdout]   5 |               return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________^
[INFO] [stdout]   6 | |                 $crate::error::eyre!(concat!("check failed: `", stringify!($cond), "`")),
[INFO] [stdout]   7 | |             )
[INFO] [stdout]   8 | |             .into());
[INFO] [stdout]     | |___________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/protocol/command/column_definition_test.rs:215:5
[INFO] [stdout]     |
[INFO] [stdout] 215 |       check!(flags.contains(ColumnFlags::PRI_KEY_FLAG));
[INFO] [stdout]     |       ------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:5:24
[INFO] [stdout]     |
[INFO] [stdout]   2 |   macro_rules! check {
[INFO] [stdout] ...
[INFO] [stdout]   5 |               return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________^
[INFO] [stdout]   6 | |                 $crate::error::eyre!(concat!("check failed: `", stringify!($cond), "`")),
[INFO] [stdout]   7 | |             )
[INFO] [stdout]   8 | |             .into());
[INFO] [stdout]     | |___________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/protocol/connection/handshake.rs:960:9
[INFO] [stdout]     |
[INFO] [stdout] 960 |           check!(matches!(action, HandshakeAction::UpgradeTls { .. }));
[INFO] [stdout]     |           ------------------------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:5:24
[INFO] [stdout]     |
[INFO] [stdout]   2 |   macro_rules! check {
[INFO] [stdout] ...
[INFO] [stdout]   5 |               return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________^
[INFO] [stdout]   6 | |                 $crate::error::eyre!(concat!("check failed: `", stringify!($cond), "`")),
[INFO] [stdout]   7 | |             )
[INFO] [stdout]   8 | |             .into());
[INFO] [stdout]     | |___________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/protocol/connection/handshake.rs:968:9
[INFO] [stdout]     |
[INFO] [stdout] 968 |           check!(matches!(action, HandshakeAction::WritePacket { .. }));
[INFO] [stdout]     |           ------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:5:24
[INFO] [stdout]     |
[INFO] [stdout]   2 |   macro_rules! check {
[INFO] [stdout] ...
[INFO] [stdout]   5 |               return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________^
[INFO] [stdout]   6 | |                 $crate::error::eyre!(concat!("check failed: `", stringify!($cond), "`")),
[INFO] [stdout]   7 | |             )
[INFO] [stdout]   8 | |             .into());
[INFO] [stdout]     | |___________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/protocol/connection/handshake.rs:976:9
[INFO] [stdout]     |
[INFO] [stdout] 976 |           check!(matches!(action, HandshakeAction::UpgradeTls { .. }));
[INFO] [stdout]     |           ------------------------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> src/test_macros.rs:5:24
[INFO] [stdout]    |
[INFO] [stdout]  2 |   macro_rules! check {
[INFO] [stdout] ...
[INFO] [stdout]  5 |               return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]    |  ________________________^
[INFO] [stdout]  6 | |                 $crate::error::eyre!(concat!("check failed: `", stringify!($cond), "`")),
[INFO] [stdout]  7 | |             )
[INFO] [stdout]  8 | |             .into());
[INFO] [stdout]    | |___________________^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/protocol/trait/param_test.rs:16:5
[INFO] [stdout]    |
[INFO] [stdout] 16 |       check!(!param.is_null());
[INFO] [stdout]    |       ------------------------ in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:5:24
[INFO] [stdout]     |
[INFO] [stdout]   2 |   macro_rules! check {
[INFO] [stdout] ...
[INFO] [stdout]   5 |               return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________^
[INFO] [stdout]   6 | |                 $crate::error::eyre!(concat!("check failed: `", stringify!($cond), "`")),
[INFO] [stdout]   7 | |             )
[INFO] [stdout]   8 | |             .into());
[INFO] [stdout]     | |___________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/protocol/trait/param_test.rs:114:5
[INFO] [stdout]     |
[INFO] [stdout] 114 |       check!(!param.is_null());
[INFO] [stdout]     |       ------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:5:24
[INFO] [stdout]     |
[INFO] [stdout]   2 |   macro_rules! check {
[INFO] [stdout] ...
[INFO] [stdout]   5 |               return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________^
[INFO] [stdout]   6 | |                 $crate::error::eyre!(concat!("check failed: `", stringify!($cond), "`")),
[INFO] [stdout]   7 | |             )
[INFO] [stdout]   8 | |             .into());
[INFO] [stdout]     | |___________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/protocol/trait/param_test.rs:129:5
[INFO] [stdout]     |
[INFO] [stdout] 129 |       check!(param.is_null());
[INFO] [stdout]     |       ----------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:5:24
[INFO] [stdout]     |
[INFO] [stdout]   2 |   macro_rules! check {
[INFO] [stdout] ...
[INFO] [stdout]   5 |               return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________^
[INFO] [stdout]   6 | |                 $crate::error::eyre!(concat!("check failed: `", stringify!($cond), "`")),
[INFO] [stdout]   7 | |             )
[INFO] [stdout]   8 | |             .into());
[INFO] [stdout]     | |___________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/protocol/trait/param_test.rs:172:5
[INFO] [stdout]     |
[INFO] [stdout] 172 |       check!(values.len() > 12);
[INFO] [stdout]     |       ------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]  --> src/test_macros.rs:5:24
[INFO] [stdout]   |
[INFO] [stdout] 2 |   macro_rules! check {
[INFO] [stdout] ...
[INFO] [stdout] 5 |               return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]   |  ________________________^
[INFO] [stdout] 6 | |                 $crate::error::eyre!(concat!("check failed: `", stringify!($cond), "`")),
[INFO] [stdout] 7 | |             )
[INFO] [stdout] 8 | |             .into());
[INFO] [stdout]   | |___________________^
[INFO] [stdout]   |
[INFO] [stdout]  ::: src/opts_test.rs:7:5
[INFO] [stdout]   |
[INFO] [stdout] 7 |       check!(opts.tcp_nodelay);
[INFO] [stdout]   |       ------------------------ in this macro invocation
[INFO] [stdout]   |
[INFO] [stdout]   = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]  --> src/test_macros.rs:5:24
[INFO] [stdout]   |
[INFO] [stdout] 2 |   macro_rules! check {
[INFO] [stdout] ...
[INFO] [stdout] 5 |               return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]   |  ________________________^
[INFO] [stdout] 6 | |                 $crate::error::eyre!(concat!("check failed: `", stringify!($cond), "`")),
[INFO] [stdout] 7 | |             )
[INFO] [stdout] 8 | |             .into());
[INFO] [stdout]   | |___________________^
[INFO] [stdout]   |
[INFO] [stdout]  ::: src/opts_test.rs:8:5
[INFO] [stdout]   |
[INFO] [stdout] 8 |       check!(!opts.compress);
[INFO] [stdout]   |       ---------------------- in this macro invocation
[INFO] [stdout]   |
[INFO] [stdout]   = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]  --> src/test_macros.rs:5:24
[INFO] [stdout]   |
[INFO] [stdout] 2 |   macro_rules! check {
[INFO] [stdout] ...
[INFO] [stdout] 5 |               return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]   |  ________________________^
[INFO] [stdout] 6 | |                 $crate::error::eyre!(concat!("check failed: `", stringify!($cond), "`")),
[INFO] [stdout] 7 | |             )
[INFO] [stdout] 8 | |             .into());
[INFO] [stdout]   | |___________________^
[INFO] [stdout]   |
[INFO] [stdout]  ::: src/opts_test.rs:9:5
[INFO] [stdout]   |
[INFO] [stdout] 9 |       check!(opts.db.is_none());
[INFO] [stdout]   |       ------------------------- in this macro invocation
[INFO] [stdout]   |
[INFO] [stdout]   = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> src/test_macros.rs:5:24
[INFO] [stdout]    |
[INFO] [stdout]  2 |   macro_rules! check {
[INFO] [stdout] ...
[INFO] [stdout]  5 |               return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]    |  ________________________^
[INFO] [stdout]  6 | |                 $crate::error::eyre!(concat!("check failed: `", stringify!($cond), "`")),
[INFO] [stdout]  7 | |             )
[INFO] [stdout]  8 | |             .into());
[INFO] [stdout]    | |___________________^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/opts_test.rs:10:5
[INFO] [stdout]    |
[INFO] [stdout] 10 |       check!(opts.host.is_empty());
[INFO] [stdout]    |       ---------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> src/test_macros.rs:5:24
[INFO] [stdout]    |
[INFO] [stdout]  2 |   macro_rules! check {
[INFO] [stdout] ...
[INFO] [stdout]  5 |               return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]    |  ________________________^
[INFO] [stdout]  6 | |                 $crate::error::eyre!(concat!("check failed: `", stringify!($cond), "`")),
[INFO] [stdout]  7 | |             )
[INFO] [stdout]  8 | |             .into());
[INFO] [stdout]    | |___________________^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/opts_test.rs:12:5
[INFO] [stdout]    |
[INFO] [stdout] 12 |       check!(opts.socket.is_none());
[INFO] [stdout]    |       ----------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> src/test_macros.rs:5:24
[INFO] [stdout]    |
[INFO] [stdout]  2 |   macro_rules! check {
[INFO] [stdout] ...
[INFO] [stdout]  5 |               return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]    |  ________________________^
[INFO] [stdout]  6 | |                 $crate::error::eyre!(concat!("check failed: `", stringify!($cond), "`")),
[INFO] [stdout]  7 | |             )
[INFO] [stdout]  8 | |             .into());
[INFO] [stdout]    | |___________________^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/opts_test.rs:13:5
[INFO] [stdout]    |
[INFO] [stdout] 13 |       check!(opts.user.is_empty());
[INFO] [stdout]    |       ---------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> src/test_macros.rs:5:24
[INFO] [stdout]    |
[INFO] [stdout]  2 |   macro_rules! check {
[INFO] [stdout] ...
[INFO] [stdout]  5 |               return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]    |  ________________________^
[INFO] [stdout]  6 | |                 $crate::error::eyre!(concat!("check failed: `", stringify!($cond), "`")),
[INFO] [stdout]  7 | |             )
[INFO] [stdout]  8 | |             .into());
[INFO] [stdout]    | |___________________^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/opts_test.rs:14:5
[INFO] [stdout]    |
[INFO] [stdout] 14 |       check!(opts.password.is_empty());
[INFO] [stdout]    |       -------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> src/test_macros.rs:5:24
[INFO] [stdout]    |
[INFO] [stdout]  2 |   macro_rules! check {
[INFO] [stdout] ...
[INFO] [stdout]  5 |               return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]    |  ________________________^
[INFO] [stdout]  6 | |                 $crate::error::eyre!(concat!("check failed: `", stringify!($cond), "`")),
[INFO] [stdout]  7 | |             )
[INFO] [stdout]  8 | |             .into());
[INFO] [stdout]    | |___________________^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/opts_test.rs:16:5
[INFO] [stdout]    |
[INFO] [stdout] 16 |       check!(opts.upgrade_to_unix_socket);
[INFO] [stdout]    |       ----------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> src/test_macros.rs:5:24
[INFO] [stdout]    |
[INFO] [stdout]  2 |   macro_rules! check {
[INFO] [stdout] ...
[INFO] [stdout]  5 |               return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]    |  ________________________^
[INFO] [stdout]  6 | |                 $crate::error::eyre!(concat!("check failed: `", stringify!($cond), "`")),
[INFO] [stdout]  7 | |             )
[INFO] [stdout]  8 | |             .into());
[INFO] [stdout]    | |___________________^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/opts_test.rs:17:5
[INFO] [stdout]    |
[INFO] [stdout] 17 |       check!(opts.init_command.is_none());
[INFO] [stdout]    |       ----------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> src/test_macros.rs:5:24
[INFO] [stdout]    |
[INFO] [stdout]  2 |   macro_rules! check {
[INFO] [stdout] ...
[INFO] [stdout]  5 |               return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]    |  ________________________^
[INFO] [stdout]  6 | |                 $crate::error::eyre!(concat!("check failed: `", stringify!($cond), "`")),
[INFO] [stdout]  7 | |             )
[INFO] [stdout]  8 | |             .into());
[INFO] [stdout]    | |___________________^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/opts_test.rs:18:5
[INFO] [stdout]    |
[INFO] [stdout] 18 |       check!(opts.pool_reset_conn);
[INFO] [stdout]    |       ---------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> src/test_macros.rs:5:24
[INFO] [stdout]    |
[INFO] [stdout]  2 |   macro_rules! check {
[INFO] [stdout] ...
[INFO] [stdout]  5 |               return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]    |  ________________________^
[INFO] [stdout]  6 | |                 $crate::error::eyre!(concat!("check failed: `", stringify!($cond), "`")),
[INFO] [stdout]  7 | |             )
[INFO] [stdout]  8 | |             .into());
[INFO] [stdout]    | |___________________^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/opts_test.rs:20:5
[INFO] [stdout]    |
[INFO] [stdout] 20 |       check!(opts.pool_max_concurrency.is_none());
[INFO] [stdout]    |       ------------------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> src/test_macros.rs:5:24
[INFO] [stdout]    |
[INFO] [stdout]  2 |   macro_rules! check {
[INFO] [stdout] ...
[INFO] [stdout]  5 |               return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]    |  ________________________^
[INFO] [stdout]  6 | |                 $crate::error::eyre!(concat!("check failed: `", stringify!($cond), "`")),
[INFO] [stdout]  7 | |             )
[INFO] [stdout]  8 | |             .into());
[INFO] [stdout]    | |___________________^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/opts_test.rs:29:5
[INFO] [stdout]    |
[INFO] [stdout] 29 |       check!(opts.user.is_empty());
[INFO] [stdout]    |       ---------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> src/test_macros.rs:5:24
[INFO] [stdout]    |
[INFO] [stdout]  2 |   macro_rules! check {
[INFO] [stdout] ...
[INFO] [stdout]  5 |               return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]    |  ________________________^
[INFO] [stdout]  6 | |                 $crate::error::eyre!(concat!("check failed: `", stringify!($cond), "`")),
[INFO] [stdout]  7 | |             )
[INFO] [stdout]  8 | |             .into());
[INFO] [stdout]    | |___________________^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/opts_test.rs:30:5
[INFO] [stdout]    |
[INFO] [stdout] 30 |       check!(opts.password.is_empty());
[INFO] [stdout]    |       -------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> src/test_macros.rs:5:24
[INFO] [stdout]    |
[INFO] [stdout]  2 |   macro_rules! check {
[INFO] [stdout] ...
[INFO] [stdout]  5 |               return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]    |  ________________________^
[INFO] [stdout]  6 | |                 $crate::error::eyre!(concat!("check failed: `", stringify!($cond), "`")),
[INFO] [stdout]  7 | |             )
[INFO] [stdout]  8 | |             .into());
[INFO] [stdout]    | |___________________^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/opts_test.rs:31:5
[INFO] [stdout]    |
[INFO] [stdout] 31 |       check!(opts.db.is_none());
[INFO] [stdout]    |       ------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> src/test_macros.rs:5:24
[INFO] [stdout]    |
[INFO] [stdout]  2 |   macro_rules! check {
[INFO] [stdout] ...
[INFO] [stdout]  5 |               return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]    |  ________________________^
[INFO] [stdout]  6 | |                 $crate::error::eyre!(concat!("check failed: `", stringify!($cond), "`")),
[INFO] [stdout]  7 | |             )
[INFO] [stdout]  8 | |             .into());
[INFO] [stdout]    | |___________________^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/opts_test.rs:63:5
[INFO] [stdout]    |
[INFO] [stdout] 63 |       check!(opts.db.is_none());
[INFO] [stdout]    |       ------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:5:24
[INFO] [stdout]     |
[INFO] [stdout]   2 |   macro_rules! check {
[INFO] [stdout] ...
[INFO] [stdout]   5 |               return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________^
[INFO] [stdout]   6 | |                 $crate::error::eyre!(concat!("check failed: `", stringify!($cond), "`")),
[INFO] [stdout]   7 | |             )
[INFO] [stdout]   8 | |             .into());
[INFO] [stdout]     | |___________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/opts_test.rs:101:5
[INFO] [stdout]     |
[INFO] [stdout] 101 |       check!(err.to_string().contains("Invalid tls_mode"));
[INFO] [stdout]     |       ---------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:5:24
[INFO] [stdout]     |
[INFO] [stdout]   2 |   macro_rules! check {
[INFO] [stdout] ...
[INFO] [stdout]   5 |               return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________^
[INFO] [stdout]   6 | |                 $crate::error::eyre!(concat!("check failed: `", stringify!($cond), "`")),
[INFO] [stdout]   7 | |             )
[INFO] [stdout]   8 | |             .into());
[INFO] [stdout]     | |___________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/opts_test.rs:108:5
[INFO] [stdout]     |
[INFO] [stdout] 108 |       check!(opts1.compress);
[INFO] [stdout]     |       ---------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:5:24
[INFO] [stdout]     |
[INFO] [stdout]   2 |   macro_rules! check {
[INFO] [stdout] ...
[INFO] [stdout]   5 |               return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________^
[INFO] [stdout]   6 | |                 $crate::error::eyre!(concat!("check failed: `", stringify!($cond), "`")),
[INFO] [stdout]   7 | |             )
[INFO] [stdout]   8 | |             .into());
[INFO] [stdout]     | |___________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/opts_test.rs:111:5
[INFO] [stdout]     |
[INFO] [stdout] 111 |       check!(!opts2.compress);
[INFO] [stdout]     |       ----------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:5:24
[INFO] [stdout]     |
[INFO] [stdout]   2 |   macro_rules! check {
[INFO] [stdout] ...
[INFO] [stdout]   5 |               return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________^
[INFO] [stdout]   6 | |                 $crate::error::eyre!(concat!("check failed: `", stringify!($cond), "`")),
[INFO] [stdout]   7 | |             )
[INFO] [stdout]   8 | |             .into());
[INFO] [stdout]     | |___________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/opts_test.rs:118:5
[INFO] [stdout]     |
[INFO] [stdout] 118 |       check!(!opts1.tcp_nodelay);
[INFO] [stdout]     |       -------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:5:24
[INFO] [stdout]     |
[INFO] [stdout]   2 |   macro_rules! check {
[INFO] [stdout] ...
[INFO] [stdout]   5 |               return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________^
[INFO] [stdout]   6 | |                 $crate::error::eyre!(concat!("check failed: `", stringify!($cond), "`")),
[INFO] [stdout]   7 | |             )
[INFO] [stdout]   8 | |             .into());
[INFO] [stdout]     | |___________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/opts_test.rs:121:5
[INFO] [stdout]     |
[INFO] [stdout] 121 |       check!(opts2.tcp_nodelay);
[INFO] [stdout]     |       ------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:5:24
[INFO] [stdout]     |
[INFO] [stdout]   2 |   macro_rules! check {
[INFO] [stdout] ...
[INFO] [stdout]   5 |               return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________^
[INFO] [stdout]   6 | |                 $crate::error::eyre!(concat!("check failed: `", stringify!($cond), "`")),
[INFO] [stdout]   7 | |             )
[INFO] [stdout]   8 | |             .into());
[INFO] [stdout]     | |___________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/opts_test.rs:128:5
[INFO] [stdout]     |
[INFO] [stdout] 128 |       check!(!opts1.upgrade_to_unix_socket);
[INFO] [stdout]     |       ------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:5:24
[INFO] [stdout]     |
[INFO] [stdout]   2 |   macro_rules! check {
[INFO] [stdout] ...
[INFO] [stdout]   5 |               return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________^
[INFO] [stdout]   6 | |                 $crate::error::eyre!(concat!("check failed: `", stringify!($cond), "`")),
[INFO] [stdout]   7 | |             )
[INFO] [stdout]   8 | |             .into());
[INFO] [stdout]     | |___________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/opts_test.rs:131:5
[INFO] [stdout]     |
[INFO] [stdout] 131 |       check!(opts2.upgrade_to_unix_socket);
[INFO] [stdout]     |       ------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:5:24
[INFO] [stdout]     |
[INFO] [stdout]   2 |   macro_rules! check {
[INFO] [stdout] ...
[INFO] [stdout]   5 |               return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________^
[INFO] [stdout]   6 | |                 $crate::error::eyre!(concat!("check failed: `", stringify!($cond), "`")),
[INFO] [stdout]   7 | |             )
[INFO] [stdout]   8 | |             .into());
[INFO] [stdout]     | |___________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/opts_test.rs:145:5
[INFO] [stdout]     |
[INFO] [stdout] 145 |       check!(!opts1.pool_reset_conn);
[INFO] [stdout]     |       ------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:5:24
[INFO] [stdout]     |
[INFO] [stdout]   2 |   macro_rules! check {
[INFO] [stdout] ...
[INFO] [stdout]   5 |               return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________^
[INFO] [stdout]   6 | |                 $crate::error::eyre!(concat!("check failed: `", stringify!($cond), "`")),
[INFO] [stdout]   7 | |             )
[INFO] [stdout]   8 | |             .into());
[INFO] [stdout]     | |___________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/opts_test.rs:148:5
[INFO] [stdout]     |
[INFO] [stdout] 148 |       check!(opts2.pool_reset_conn);
[INFO] [stdout]     |       ----------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:5:24
[INFO] [stdout]     |
[INFO] [stdout]   2 |   macro_rules! check {
[INFO] [stdout] ...
[INFO] [stdout]   5 |               return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________^
[INFO] [stdout]   6 | |                 $crate::error::eyre!(concat!("check failed: `", stringify!($cond), "`")),
[INFO] [stdout]   7 | |             )
[INFO] [stdout]   8 | |             .into());
[INFO] [stdout]     | |___________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/opts_test.rs:180:5
[INFO] [stdout]     |
[INFO] [stdout] 180 |       check!(opts.compress);
[INFO] [stdout]     |       --------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:5:24
[INFO] [stdout]     |
[INFO] [stdout]   2 |   macro_rules! check {
[INFO] [stdout] ...
[INFO] [stdout]   5 |               return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________^
[INFO] [stdout]   6 | |                 $crate::error::eyre!(concat!("check failed: `", stringify!($cond), "`")),
[INFO] [stdout]   7 | |             )
[INFO] [stdout]   8 | |             .into());
[INFO] [stdout]     | |___________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/opts_test.rs:189:5
[INFO] [stdout]     |
[INFO] [stdout] 189 |       check!(err.to_string().contains("Invalid URL scheme"));
[INFO] [stdout]     |       ------------------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:5:24
[INFO] [stdout]     |
[INFO] [stdout]   2 |   macro_rules! check {
[INFO] [stdout] ...
[INFO] [stdout]   5 |               return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________^
[INFO] [stdout]   6 | |                 $crate::error::eyre!(concat!("check failed: `", stringify!($cond), "`")),
[INFO] [stdout]   7 | |             )
[INFO] [stdout]   8 | |             .into());
[INFO] [stdout]     | |___________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/opts_test.rs:197:5
[INFO] [stdout]     |
[INFO] [stdout] 197 |       check!(err.to_string().contains("Failed to parse MySQL URL"));
[INFO] [stdout]     |       ------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:5:24
[INFO] [stdout]     |
[INFO] [stdout]   2 |   macro_rules! check {
[INFO] [stdout] ...
[INFO] [stdout]   5 |               return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________^
[INFO] [stdout]   6 | |                 $crate::error::eyre!(concat!("check failed: `", stringify!($cond), "`")),
[INFO] [stdout]   7 | |             )
[INFO] [stdout]   8 | |             .into());
[INFO] [stdout]     | |___________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/opts_test.rs:205:5
[INFO] [stdout]     |
[INFO] [stdout] 205 |       check!(err.to_string().contains("Unknown query parameter"));
[INFO] [stdout]     |       ----------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:5:24
[INFO] [stdout]     |
[INFO] [stdout]   2 |   macro_rules! check {
[INFO] [stdout] ...
[INFO] [stdout]   5 |               return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________^
[INFO] [stdout]   6 | |                 $crate::error::eyre!(concat!("check failed: `", stringify!($cond), "`")),
[INFO] [stdout]   7 | |             )
[INFO] [stdout]   8 | |             .into());
[INFO] [stdout]     | |___________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/opts_test.rs:213:5
[INFO] [stdout]     |
[INFO] [stdout] 213 |       check!(err.to_string().contains("Invalid boolean value"));
[INFO] [stdout]     |       --------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:5:24
[INFO] [stdout]     |
[INFO] [stdout]   2 |   macro_rules! check {
[INFO] [stdout] ...
[INFO] [stdout]   5 |               return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________^
[INFO] [stdout]   6 | |                 $crate::error::eyre!(concat!("check failed: `", stringify!($cond), "`")),
[INFO] [stdout]   7 | |             )
[INFO] [stdout]   8 | |             .into());
[INFO] [stdout]     | |___________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/opts_test.rs:221:5
[INFO] [stdout]     |
[INFO] [stdout] 221 |       check!(err.to_string().contains("Invalid unsigned integer value"));
[INFO] [stdout]     |       ------------------------------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:5:24
[INFO] [stdout]     |
[INFO] [stdout]   2 |   macro_rules! check {
[INFO] [stdout] ...
[INFO] [stdout]   5 |               return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________^
[INFO] [stdout]   6 | |                 $crate::error::eyre!(concat!("check failed: `", stringify!($cond), "`")),
[INFO] [stdout]   7 | |             )
[INFO] [stdout]   8 | |             .into());
[INFO] [stdout]     | |___________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/opts_test.rs:274:5
[INFO] [stdout]     |
[INFO] [stdout] 274 |       check!(err.to_string().contains("Invalid UTF-8 in URL"));
[INFO] [stdout]     |       -------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:5:24
[INFO] [stdout]     |
[INFO] [stdout]   2 |   macro_rules! check {
[INFO] [stdout] ...
[INFO] [stdout]   5 |               return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________^
[INFO] [stdout]   6 | |                 $crate::error::eyre!(concat!("check failed: `", stringify!($cond), "`")),
[INFO] [stdout]   7 | |             )
[INFO] [stdout]   8 | |             .into());
[INFO] [stdout]     | |___________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/opts_test.rs:283:5
[INFO] [stdout]     |
[INFO] [stdout] 283 |       check!(opts.password.is_empty());
[INFO] [stdout]     |       -------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:5:24
[INFO] [stdout]     |
[INFO] [stdout]   2 |   macro_rules! check {
[INFO] [stdout] ...
[INFO] [stdout]   5 |               return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________^
[INFO] [stdout]   6 | |                 $crate::error::eyre!(concat!("check failed: `", stringify!($cond), "`")),
[INFO] [stdout]   7 | |             )
[INFO] [stdout]   8 | |             .into());
[INFO] [stdout]     | |___________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/opts_test.rs:291:5
[INFO] [stdout]     |
[INFO] [stdout] 291 |       check!(opts.password.is_empty());
[INFO] [stdout]     |       -------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> src/test_macros.rs:5:24
[INFO] [stdout]    |
[INFO] [stdout]  2 |   macro_rules! check {
[INFO] [stdout] ...
[INFO] [stdout]  5 |               return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]    |  ________________________^
[INFO] [stdout]  6 | |                 $crate::error::eyre!(concat!("check failed: `", stringify!($cond), "`")),
[INFO] [stdout]  7 | |             )
[INFO] [stdout]  8 | |             .into());
[INFO] [stdout]    | |___________________^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/value_test.rs:31:5
[INFO] [stdout]    |
[INFO] [stdout] 31 |       check!(matches!(value, Value::SignedInt(-42)));
[INFO] [stdout]    |       ---------------------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> src/test_macros.rs:5:24
[INFO] [stdout]    |
[INFO] [stdout]  2 |   macro_rules! check {
[INFO] [stdout] ...
[INFO] [stdout]  5 |               return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]    |  ________________________^
[INFO] [stdout]  6 | |                 $crate::error::eyre!(concat!("check failed: `", stringify!($cond), "`")),
[INFO] [stdout]  7 | |             )
[INFO] [stdout]  8 | |             .into());
[INFO] [stdout]    | |___________________^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/value_test.rs:38:5
[INFO] [stdout]    |
[INFO] [stdout] 38 |       check!(matches!(value2, Value::SignedInt(-1000)));
[INFO] [stdout]    |       ------------------------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> src/test_macros.rs:5:24
[INFO] [stdout]    |
[INFO] [stdout]  2 |   macro_rules! check {
[INFO] [stdout] ...
[INFO] [stdout]  5 |               return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]    |  ________________________^
[INFO] [stdout]  6 | |                 $crate::error::eyre!(concat!("check failed: `", stringify!($cond), "`")),
[INFO] [stdout]  7 | |             )
[INFO] [stdout]  8 | |             .into());
[INFO] [stdout]    | |___________________^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/value_test.rs:45:5
[INFO] [stdout]    |
[INFO] [stdout] 45 |       check!(matches!(value3, Value::SignedInt(-100000)));
[INFO] [stdout]    |       --------------------------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> src/test_macros.rs:5:24
[INFO] [stdout]    |
[INFO] [stdout]  2 |   macro_rules! check {
[INFO] [stdout] ...
[INFO] [stdout]  5 |               return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]    |  ________________________^
[INFO] [stdout]  6 | |                 $crate::error::eyre!(concat!("check failed: `", stringify!($cond), "`")),
[INFO] [stdout]  7 | |             )
[INFO] [stdout]  8 | |             .into());
[INFO] [stdout]    | |___________________^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/value_test.rs:57:5
[INFO] [stdout]    |
[INFO] [stdout] 57 |       check!(matches!(value, Value::UnsignedInt(200)));
[INFO] [stdout]    |       ------------------------------------------------ in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> src/test_macros.rs:5:24
[INFO] [stdout]    |
[INFO] [stdout]  2 |   macro_rules! check {
[INFO] [stdout] ...
[INFO] [stdout]  5 |               return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]    |  ________________________^
[INFO] [stdout]  6 | |                 $crate::error::eyre!(concat!("check failed: `", stringify!($cond), "`")),
[INFO] [stdout]  7 | |             )
[INFO] [stdout]  8 | |             .into());
[INFO] [stdout]    | |___________________^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/value_test.rs:64:5
[INFO] [stdout]    |
[INFO] [stdout] 64 |       check!(matches!(value2, Value::UnsignedInt(0x7FFF_FFFF_FFFF_FFFF)));
[INFO] [stdout]    |       ------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> src/test_macros.rs:5:24
[INFO] [stdout]    |
[INFO] [stdout]  2 |   macro_rules! check {
[INFO] [stdout] ...
[INFO] [stdout]  5 |               return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]    |  ________________________^
[INFO] [stdout]  6 | |                 $crate::error::eyre!(concat!("check failed: `", stringify!($cond), "`")),
[INFO] [stdout]  7 | |             )
[INFO] [stdout]  8 | |             .into());
[INFO] [stdout]    | |___________________^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/value_test.rs:82:5
[INFO] [stdout]    |
[INFO] [stdout] 82 |       check!(close);
[INFO] [stdout]    |       ------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]   --> src/test_macros.rs:5:24
[INFO] [stdout]    |
[INFO] [stdout]  2 |   macro_rules! check {
[INFO] [stdout] ...
[INFO] [stdout]  5 |               return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]    |  ________________________^
[INFO] [stdout]  6 | |                 $crate::error::eyre!(concat!("check failed: `", stringify!($cond), "`")),
[INFO] [stdout]  7 | |             )
[INFO] [stdout]  8 | |             .into());
[INFO] [stdout]    | |___________________^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/value_test.rs:95:5
[INFO] [stdout]    |
[INFO] [stdout] 95 |       check!(close2);
[INFO] [stdout]    |       -------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:5:24
[INFO] [stdout]     |
[INFO] [stdout]   2 |   macro_rules! check {
[INFO] [stdout] ...
[INFO] [stdout]   5 |               return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________^
[INFO] [stdout]   6 | |                 $crate::error::eyre!(concat!("check failed: `", stringify!($cond), "`")),
[INFO] [stdout]   7 | |             )
[INFO] [stdout]   8 | |             .into());
[INFO] [stdout]     | |___________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/value_test.rs:108:5
[INFO] [stdout]     |
[INFO] [stdout] 108 |       check!(matches!(value, Value::Datetime0));
[INFO] [stdout]     |       ----------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:5:24
[INFO] [stdout]     |
[INFO] [stdout]   2 |   macro_rules! check {
[INFO] [stdout] ...
[INFO] [stdout]   5 |               return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________^
[INFO] [stdout]   6 | |                 $crate::error::eyre!(concat!("check failed: `", stringify!($cond), "`")),
[INFO] [stdout]   7 | |             )
[INFO] [stdout]   8 | |             .into());
[INFO] [stdout]     | |___________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/value_test.rs:159:5
[INFO] [stdout]     |
[INFO] [stdout] 159 |       check!(matches!(value, Value::Date0));
[INFO] [stdout]     |       ------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:5:24
[INFO] [stdout]     |
[INFO] [stdout]   2 |   macro_rules! check {
[INFO] [stdout] ...
[INFO] [stdout]   5 |               return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________^
[INFO] [stdout]   6 | |                 $crate::error::eyre!(concat!("check failed: `", stringify!($cond), "`")),
[INFO] [stdout]   7 | |             )
[INFO] [stdout]   8 | |             .into());
[INFO] [stdout]     | |___________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/value_test.rs:189:5
[INFO] [stdout]     |
[INFO] [stdout] 189 |       check!(matches!(value, Value::Time0));
[INFO] [stdout]     |       ------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:5:24
[INFO] [stdout]     |
[INFO] [stdout]   2 |   macro_rules! check {
[INFO] [stdout] ...
[INFO] [stdout]   5 |               return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________^
[INFO] [stdout]   6 | |                 $crate::error::eyre!(concat!("check failed: `", stringify!($cond), "`")),
[INFO] [stdout]   7 | |             )
[INFO] [stdout]   8 | |             .into());
[INFO] [stdout]     | |___________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/value_test.rs:205:5
[INFO] [stdout]     |
[INFO] [stdout] 205 |       check!(time.is_negative());
[INFO] [stdout]     |       -------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:5:24
[INFO] [stdout]     |
[INFO] [stdout]   2 |   macro_rules! check {
[INFO] [stdout] ...
[INFO] [stdout]   5 |               return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________^
[INFO] [stdout]   6 | |                 $crate::error::eyre!(concat!("check failed: `", stringify!($cond), "`")),
[INFO] [stdout]   7 | |             )
[INFO] [stdout]   8 | |             .into());
[INFO] [stdout]     | |___________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/value_test.rs:259:5
[INFO] [stdout]     |
[INFO] [stdout] 259 |       check!(matches!(value, Value::Null));
[INFO] [stdout]     |       ------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:5:24
[INFO] [stdout]     |
[INFO] [stdout]   2 |   macro_rules! check {
[INFO] [stdout] ...
[INFO] [stdout]   5 |               return Err($crate::error::Error::LibraryBug(
[INFO] [stdout]     |  ________________________^
[INFO] [stdout]   6 | |                 $crate::error::eyre!(concat!("check failed: `", stringify!($cond), "`")),
[INFO] [stdout]   7 | |             )
[INFO] [stdout]   8 | |             .into());
[INFO] [stdout]     | |___________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/value_test.rs:271:5
[INFO] [stdout]     |
[INFO] [stdout] 271 |       check!(matches!(value, Value::UnsignedInt(42)));
[INFO] [stdout]     |       ----------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:56:21
[INFO] [stdout]     |
[INFO] [stdout]  50 |   macro_rules! check_err {
[INFO] [stdout] ...
[INFO] [stdout]  56 | /                     $crate::error::Error::LibraryBug($crate::error::eyre!(concat!(
[INFO] [stdout]  57 | |                         "expected Err: `",
[INFO] [stdout]  58 | |                         stringify!($result),
[INFO] [stdout]  59 | |                         "`"
[INFO] [stdout]  60 | |                     )))
[INFO] [stdout]  61 | |                     .into(),
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/protocol/command/column_definition_test.rs:114:16
[INFO] [stdout]     |
[INFO] [stdout] 114 |       let _err = check_err!(result);
[INFO] [stdout]     |                  ------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:56:21
[INFO] [stdout]     |
[INFO] [stdout]  50 |   macro_rules! check_err {
[INFO] [stdout] ...
[INFO] [stdout]  56 | /                     $crate::error::Error::LibraryBug($crate::error::eyre!(concat!(
[INFO] [stdout]  57 | |                         "expected Err: `",
[INFO] [stdout]  58 | |                         stringify!($result),
[INFO] [stdout]  59 | |                         "`"
[INFO] [stdout]  60 | |                     )))
[INFO] [stdout]  61 | |                     .into(),
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/protocol/command/column_definition_test.rs:152:16
[INFO] [stdout]     |
[INFO] [stdout] 152 |       let _err = check_err!(result);
[INFO] [stdout]     |                  ------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:56:21
[INFO] [stdout]     |
[INFO] [stdout]  50 |   macro_rules! check_err {
[INFO] [stdout] ...
[INFO] [stdout]  56 | /                     $crate::error::Error::LibraryBug($crate::error::eyre!(concat!(
[INFO] [stdout]  57 | |                         "expected Err: `",
[INFO] [stdout]  58 | |                         stringify!($result),
[INFO] [stdout]  59 | |                         "`"
[INFO] [stdout]  60 | |                     )))
[INFO] [stdout]  61 | |                     .into(),
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/protocol/connection/handshake.rs:882:9
[INFO] [stdout]     |
[INFO] [stdout] 882 |           check_err!(read_caching_sha2_password_fast_auth_result(&[0x05]));
[INFO] [stdout]     |           ---------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:56:21
[INFO] [stdout]     |
[INFO] [stdout]  50 |   macro_rules! check_err {
[INFO] [stdout] ...
[INFO] [stdout]  56 | /                     $crate::error::Error::LibraryBug($crate::error::eyre!(concat!(
[INFO] [stdout]  57 | |                         "expected Err: `",
[INFO] [stdout]  58 | |                         stringify!($result),
[INFO] [stdout]  59 | |                         "`"
[INFO] [stdout]  60 | |                     )))
[INFO] [stdout]  61 | |                     .into(),
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/protocol/connection/handshake.rs:883:9
[INFO] [stdout]     |
[INFO] [stdout] 883 |           check_err!(read_caching_sha2_password_fast_auth_result(&[]));
[INFO] [stdout]     |           ------------------------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:56:21
[INFO] [stdout]     |
[INFO] [stdout]  50 |   macro_rules! check_err {
[INFO] [stdout] ...
[INFO] [stdout]  56 | /                     $crate::error::Error::LibraryBug($crate::error::eyre!(concat!(
[INFO] [stdout]  57 | |                         "expected Err: `",
[INFO] [stdout]  58 | |                         stringify!($result),
[INFO] [stdout]  59 | |                         "`"
[INFO] [stdout]  60 | |                     )))
[INFO] [stdout]  61 | |                     .into(),
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/protocol/connection/handshake.rs:943:9
[INFO] [stdout]     |
[INFO] [stdout] 943 |           check_err!(handshake.step(&mut buffer_set));
[INFO] [stdout]     |           ------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:56:21
[INFO] [stdout]     |
[INFO] [stdout]  50 |   macro_rules! check_err {
[INFO] [stdout] ...
[INFO] [stdout]  56 | /                     $crate::error::Error::LibraryBug($crate::error::eyre!(concat!(
[INFO] [stdout]  57 | |                         "expected Err: `",
[INFO] [stdout]  58 | |                         stringify!($result),
[INFO] [stdout]  59 | |                         "`"
[INFO] [stdout]  60 | |                     )))
[INFO] [stdout]  61 | |                     .into(),
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/protocol/connection/handshake.rs:983:9
[INFO] [stdout]     |
[INFO] [stdout] 983 | /         check_err!(step_initial_handshake(
[INFO] [stdout] 984 | |             TlsMode::Require,
[INFO] [stdout] 985 | |             false,
[INFO] [stdout] 986 | |             &mut buffer_set
[INFO] [stdout] 987 | |         ));
[INFO] [stdout]     | |__________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:56:21
[INFO] [stdout]     |
[INFO] [stdout]  50 |   macro_rules! check_err {
[INFO] [stdout] ...
[INFO] [stdout]  56 | /                     $crate::error::Error::LibraryBug($crate::error::eyre!(concat!(
[INFO] [stdout]  57 | |                         "expected Err: `",
[INFO] [stdout]  58 | |                         stringify!($result),
[INFO] [stdout]  59 | |                         "`"
[INFO] [stdout]  60 | |                     )))
[INFO] [stdout]  61 | |                     .into(),
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/opts_test.rs:100:15
[INFO] [stdout]     |
[INFO] [stdout] 100 |       let err = check_err!(Opts::try_from("mysql://localhost?tls_mode=true"));
[INFO] [stdout]     |                 ------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:56:21
[INFO] [stdout]     |
[INFO] [stdout]  50 |   macro_rules! check_err {
[INFO] [stdout] ...
[INFO] [stdout]  56 | /                     $crate::error::Error::LibraryBug($crate::error::eyre!(concat!(
[INFO] [stdout]  57 | |                         "expected Err: `",
[INFO] [stdout]  58 | |                         stringify!($result),
[INFO] [stdout]  59 | |                         "`"
[INFO] [stdout]  60 | |                     )))
[INFO] [stdout]  61 | |                     .into(),
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/opts_test.rs:188:15
[INFO] [stdout]     |
[INFO] [stdout] 188 |       let err = check_err!(result);
[INFO] [stdout]     |                 ------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:56:21
[INFO] [stdout]     |
[INFO] [stdout]  50 |   macro_rules! check_err {
[INFO] [stdout] ...
[INFO] [stdout]  56 | /                     $crate::error::Error::LibraryBug($crate::error::eyre!(concat!(
[INFO] [stdout]  57 | |                         "expected Err: `",
[INFO] [stdout]  58 | |                         stringify!($result),
[INFO] [stdout]  59 | |                         "`"
[INFO] [stdout]  60 | |                     )))
[INFO] [stdout]  61 | |                     .into(),
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/opts_test.rs:196:15
[INFO] [stdout]     |
[INFO] [stdout] 196 |       let err = check_err!(result);
[INFO] [stdout]     |                 ------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:56:21
[INFO] [stdout]     |
[INFO] [stdout]  50 |   macro_rules! check_err {
[INFO] [stdout] ...
[INFO] [stdout]  56 | /                     $crate::error::Error::LibraryBug($crate::error::eyre!(concat!(
[INFO] [stdout]  57 | |                         "expected Err: `",
[INFO] [stdout]  58 | |                         stringify!($result),
[INFO] [stdout]  59 | |                         "`"
[INFO] [stdout]  60 | |                     )))
[INFO] [stdout]  61 | |                     .into(),
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/opts_test.rs:204:15
[INFO] [stdout]     |
[INFO] [stdout] 204 |       let err = check_err!(result);
[INFO] [stdout]     |                 ------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:56:21
[INFO] [stdout]     |
[INFO] [stdout]  50 |   macro_rules! check_err {
[INFO] [stdout] ...
[INFO] [stdout]  56 | /                     $crate::error::Error::LibraryBug($crate::error::eyre!(concat!(
[INFO] [stdout]  57 | |                         "expected Err: `",
[INFO] [stdout]  58 | |                         stringify!($result),
[INFO] [stdout]  59 | |                         "`"
[INFO] [stdout]  60 | |                     )))
[INFO] [stdout]  61 | |                     .into(),
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/opts_test.rs:212:15
[INFO] [stdout]     |
[INFO] [stdout] 212 |       let err = check_err!(result);
[INFO] [stdout]     |                 ------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:56:21
[INFO] [stdout]     |
[INFO] [stdout]  50 |   macro_rules! check_err {
[INFO] [stdout] ...
[INFO] [stdout]  56 | /                     $crate::error::Error::LibraryBug($crate::error::eyre!(concat!(
[INFO] [stdout]  57 | |                         "expected Err: `",
[INFO] [stdout]  58 | |                         stringify!($result),
[INFO] [stdout]  59 | |                         "`"
[INFO] [stdout]  60 | |                     )))
[INFO] [stdout]  61 | |                     .into(),
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/opts_test.rs:220:15
[INFO] [stdout]     |
[INFO] [stdout] 220 |       let err = check_err!(result);
[INFO] [stdout]     |                 ------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:56:21
[INFO] [stdout]     |
[INFO] [stdout]  50 |   macro_rules! check_err {
[INFO] [stdout] ...
[INFO] [stdout]  56 | /                     $crate::error::Error::LibraryBug($crate::error::eyre!(concat!(
[INFO] [stdout]  57 | |                         "expected Err: `",
[INFO] [stdout]  58 | |                         stringify!($result),
[INFO] [stdout]  59 | |                         "`"
[INFO] [stdout]  60 | |                     )))
[INFO] [stdout]  61 | |                     .into(),
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/opts_test.rs:228:5
[INFO] [stdout]     |
[INFO] [stdout] 228 |       check_err!(result);
[INFO] [stdout]     |       ------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/test_macros.rs:56:21
[INFO] [stdout]     |
[INFO] [stdout]  50 |   macro_rules! check_err {
[INFO] [stdout] ...
[INFO] [stdout]  56 | /                     $crate::error::Error::LibraryBug($crate::error::eyre!(concat!(
[INFO] [stdout]  57 | |                         "expected Err: `",
[INFO] [stdout]  58 | |                         stringify!($result),
[INFO] [stdout]  59 | |                         "`"
[INFO] [stdout]  60 | |                     )))
[INFO] [stdout]  61 | |                     .into(),
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/opts_test.rs:273:15
[INFO] [stdout]     |
[INFO] [stdout] 273 |       let err = check_err!(Opts::try_from("mysql://root:%FF@localhost"));
[INFO] [stdout]     |                 -------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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: you can instead use the fully-qualified path `<error::Error as Into<error::Error>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `zero-mysql` (lib test) due to 230 previous errors
[INFO] [stderr] warning: unused dependency `log`
[INFO] [stderr]   --> Cargo.toml:16:1
[INFO] [stderr]    |
[INFO] [stderr] 16 | log = "0.4"
[INFO] [stderr]    | ^^^^^^^^^^^
[INFO] [stderr]    |
[INFO] [stderr]    = note: `cargo::unused_dependencies` is set to `warn` by default
[INFO] [stderr] help: consider removing the dependency on `log`
[INFO] [stderr] warning: `zero-mysql` (manifest) generated 1 warning
[INFO] running `Command { std: "docker" "inspect" "d986c30a59ab5c5860c62361343af6181b81aea29cd10f7efbbc756f67991f1b", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "d986c30a59ab5c5860c62361343af6181b81aea29cd10f7efbbc756f67991f1b", kill_on_drop: false }`
[INFO] [stdout] d986c30a59ab5c5860c62361343af6181b81aea29cd10f7efbbc756f67991f1b
