[INFO] fetching crate cassandra-protocol 4.0.1...
[INFO] checking cassandra-protocol-4.0.1 against 52995a223f2919dd3e2e427231db90a257350ded for pr-129249-4
[INFO] extracting crate cassandra-protocol 4.0.1 into /workspace/builds/worker-4-tc2/source
[INFO] started tweaking crates.io crate cassandra-protocol 4.0.1
[INFO] finished tweaking crates.io crate cassandra-protocol 4.0.1
[INFO] tweaked toml for crates.io crate cassandra-protocol 4.0.1 written to /workspace/builds/worker-4-tc2/source/Cargo.toml
[INFO] validating manifest of crates.io crate cassandra-protocol 4.0.1 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 crates.io crate cassandra-protocol 4.0.1 already has a lockfile, it will not be regenerated
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+52995a223f2919dd3e2e427231db90a257350ded" "fetch" "--manifest-path" "Cargo.toml", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-4-tc2/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-4-tc2/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/cargo-home:/opt/rustwide/cargo-home:ro,Z" "-v" "/var/lib/crater-agent-workspace/rustup-home:/opt/rustwide/rustup-home:ro,Z" "-m" "1610612736" "--network" "none" "ghcr.io/rust-lang/crates-build-env/linux@sha256:c0af3998e971868164375a7dfb646c9933ddd1a3bdb00fa2041266763dc1eeab" "sleep" "infinity", kill_on_drop: false }`
[INFO] [stdout] f92e0ba97a6348c80dbb35745938487905ebb775fd644289e8745dc595b73429
[INFO] running `Command { std: "docker" "start" "f92e0ba97a6348c80dbb35745938487905ebb775fd644289e8745dc595b73429", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "f92e0ba97a6348c80dbb35745938487905ebb775fd644289e8745dc595b73429", 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" "f92e0ba97a6348c80dbb35745938487905ebb775fd644289e8745dc595b73429" "/opt/rustwide/cargo-home/bin/cargo" "+52995a223f2919dd3e2e427231db90a257350ded" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "f92e0ba97a6348c80dbb35745938487905ebb775fd644289e8745dc595b73429", 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" "f92e0ba97a6348c80dbb35745938487905ebb775fd644289e8745dc595b73429" "/opt/rustwide/cargo-home/bin/cargo" "+52995a223f2919dd3e2e427231db90a257350ded" "check" "--frozen" "--all" "--all-targets" "--message-format=json", kill_on_drop: false }`
[INFO] [stderr]    Compiling proc-macro2 v1.0.103
[INFO] [stderr]    Compiling quote v1.0.42
[INFO] [stderr]    Compiling num-traits v0.2.19
[INFO] [stderr]    Compiling snap v1.1.1
[INFO] [stderr]    Compiling thiserror v2.0.17
[INFO] [stderr]    Compiling time-macros v0.2.22
[INFO] [stderr]     Checking twox-hash v2.1.2
[INFO] [stderr]     Checking crc32fast v1.5.0
[INFO] [stderr]     Checking lz4_flex v0.13.0
[INFO] [stderr]     Checking bytes v1.11.0
[INFO] [stderr]     Checking arc-swap v1.7.1
[INFO] [stderr]     Checking integer-encoding v4.1.0
[INFO] [stderr]     Checking bitflags v2.10.0
[INFO] [stderr]     Checking float_eq v1.0.1
[INFO] [stderr]     Checking uuid v1.19.0
[INFO] [stderr]     Checking time v0.3.41
[INFO] [stderr]     Checking num-integer v0.1.46
[INFO] [stderr]     Checking chrono v0.4.40
[INFO] [stderr]    Compiling syn v2.0.111
[INFO] [stderr]    Compiling syn v1.0.109
[INFO] [stderr]     Checking num-bigint v0.4.6
[INFO] [stderr]    Compiling derive_more-impl v2.1.0
[INFO] [stderr]    Compiling thiserror-impl v2.0.17
[INFO] [stderr]    Compiling derivative v2.2.0
[INFO] [stderr]     Checking derive_more v2.1.0
[INFO] [stderr]     Checking cassandra-protocol v4.0.1 (/opt/rustwide/workdir)
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/macros.rs:837:49
[INFO] [stdout]     |
[INFO] [stdout] 767 | macro_rules! into_rust_by_index {
[INFO] [stdout] ...
[INFO] [stdout] 837 |                         converted.map_err(|err| err.into())
[INFO] [stdout]     |                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/types/tuple.rs:65:1
[INFO] [stdout]     |
[INFO] [stdout]  65 | into_rust_by_index!(Tuple, Blob);
[INFO] [stdout]     | -------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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/macros.rs:837:49
[INFO] [stdout]     |
[INFO] [stdout] 767 | macro_rules! into_rust_by_index {
[INFO] [stdout] ...
[INFO] [stdout] 837 |                         converted.map_err(|err| err.into())
[INFO] [stdout]     |                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/types/tuple.rs:66:1
[INFO] [stdout]     |
[INFO] [stdout]  66 | into_rust_by_index!(Tuple, 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/macros.rs:837:49
[INFO] [stdout]     |
[INFO] [stdout] 767 | macro_rules! into_rust_by_index {
[INFO] [stdout] ...
[INFO] [stdout] 837 |                         converted.map_err(|err| err.into())
[INFO] [stdout]     |                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/types/tuple.rs:67:1
[INFO] [stdout]     |
[INFO] [stdout]  67 | into_rust_by_index!(Tuple, bool);
[INFO] [stdout]     | -------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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/macros.rs:837:49
[INFO] [stdout]     |
[INFO] [stdout] 767 | macro_rules! into_rust_by_index {
[INFO] [stdout] ...
[INFO] [stdout] 837 |                         converted.map_err(|err| err.into())
[INFO] [stdout]     |                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/types/tuple.rs:68:1
[INFO] [stdout]     |
[INFO] [stdout]  68 | into_rust_by_index!(Tuple, i64);
[INFO] [stdout]     | ------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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/macros.rs:837:49
[INFO] [stdout]     |
[INFO] [stdout] 767 | macro_rules! into_rust_by_index {
[INFO] [stdout] ...
[INFO] [stdout] 837 |                         converted.map_err(|err| err.into())
[INFO] [stdout]     |                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/types/tuple.rs:69:1
[INFO] [stdout]     |
[INFO] [stdout]  69 | into_rust_by_index!(Tuple, 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/macros.rs:837:49
[INFO] [stdout]     |
[INFO] [stdout] 767 | macro_rules! into_rust_by_index {
[INFO] [stdout] ...
[INFO] [stdout] 837 |                         converted.map_err(|err| err.into())
[INFO] [stdout]     |                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/types/tuple.rs:70:1
[INFO] [stdout]     |
[INFO] [stdout]  70 | into_rust_by_index!(Tuple, i16);
[INFO] [stdout]     | ------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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/macros.rs:837:49
[INFO] [stdout]     |
[INFO] [stdout] 767 | macro_rules! into_rust_by_index {
[INFO] [stdout] ...
[INFO] [stdout] 837 |                         converted.map_err(|err| err.into())
[INFO] [stdout]     |                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/types/tuple.rs:71:1
[INFO] [stdout]     |
[INFO] [stdout]  71 | into_rust_by_index!(Tuple, i8);
[INFO] [stdout]     | ------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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/macros.rs:837:49
[INFO] [stdout]     |
[INFO] [stdout] 767 | macro_rules! into_rust_by_index {
[INFO] [stdout] ...
[INFO] [stdout] 837 |                         converted.map_err(|err| err.into())
[INFO] [stdout]     |                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/types/tuple.rs:72:1
[INFO] [stdout]     |
[INFO] [stdout]  72 | into_rust_by_index!(Tuple, f64);
[INFO] [stdout]     | ------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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/macros.rs:837:49
[INFO] [stdout]     |
[INFO] [stdout] 767 | macro_rules! into_rust_by_index {
[INFO] [stdout] ...
[INFO] [stdout] 837 |                         converted.map_err(|err| err.into())
[INFO] [stdout]     |                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/types/tuple.rs:73:1
[INFO] [stdout]     |
[INFO] [stdout]  73 | into_rust_by_index!(Tuple, f32);
[INFO] [stdout]     | ------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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/macros.rs:837:49
[INFO] [stdout]     |
[INFO] [stdout] 767 | macro_rules! into_rust_by_index {
[INFO] [stdout] ...
[INFO] [stdout] 837 |                         converted.map_err(|err| err.into())
[INFO] [stdout]     |                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/types/tuple.rs:74:1
[INFO] [stdout]     |
[INFO] [stdout]  74 | into_rust_by_index!(Tuple, IpAddr);
[INFO] [stdout]     | ---------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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/macros.rs:837:49
[INFO] [stdout]     |
[INFO] [stdout] 767 | macro_rules! into_rust_by_index {
[INFO] [stdout] ...
[INFO] [stdout] 837 |                         converted.map_err(|err| err.into())
[INFO] [stdout]     |                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/types/tuple.rs:75:1
[INFO] [stdout]     |
[INFO] [stdout]  75 | into_rust_by_index!(Tuple, Uuid);
[INFO] [stdout]     | -------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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/macros.rs:778:49
[INFO] [stdout]     |
[INFO] [stdout] 767 | macro_rules! into_rust_by_index {
[INFO] [stdout] ...
[INFO] [stdout] 778 |                         converted.map_err(|err| err.into())
[INFO] [stdout]     |                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/types/tuple.rs:76:1
[INFO] [stdout]     |
[INFO] [stdout]  76 | into_rust_by_index!(Tuple, List);
[INFO] [stdout]     | -------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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/macros.rs:793:49
[INFO] [stdout]     |
[INFO] [stdout] 767 | macro_rules! into_rust_by_index {
[INFO] [stdout] ...
[INFO] [stdout] 793 |                         converted.map_err(|err| err.into())
[INFO] [stdout]     |                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/types/tuple.rs:77:1
[INFO] [stdout]     |
[INFO] [stdout]  77 | into_rust_by_index!(Tuple, Map);
[INFO] [stdout]     | ------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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/macros.rs:808:49
[INFO] [stdout]     |
[INFO] [stdout] 767 | macro_rules! into_rust_by_index {
[INFO] [stdout] ...
[INFO] [stdout] 808 |                         converted.map_err(|err| err.into())
[INFO] [stdout]     |                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/types/tuple.rs:78:1
[INFO] [stdout]     |
[INFO] [stdout]  78 | into_rust_by_index!(Tuple, Udt);
[INFO] [stdout]     | ------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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/macros.rs:823:49
[INFO] [stdout]     |
[INFO] [stdout] 767 | macro_rules! into_rust_by_index {
[INFO] [stdout] ...
[INFO] [stdout] 823 |                         converted.map_err(|err| err.into())
[INFO] [stdout]     |                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/types/tuple.rs:79:1
[INFO] [stdout]     |
[INFO] [stdout]  79 | into_rust_by_index!(Tuple, Tuple);
[INFO] [stdout]     | --------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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/macros.rs:837:49
[INFO] [stdout]     |
[INFO] [stdout] 767 | macro_rules! into_rust_by_index {
[INFO] [stdout] ...
[INFO] [stdout] 837 |                         converted.map_err(|err| err.into())
[INFO] [stdout]     |                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/types/tuple.rs:80:1
[INFO] [stdout]     |
[INFO] [stdout]  80 | into_rust_by_index!(Tuple, PrimitiveDateTime);
[INFO] [stdout]     | --------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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/macros.rs:837:49
[INFO] [stdout]     |
[INFO] [stdout] 767 | macro_rules! into_rust_by_index {
[INFO] [stdout] ...
[INFO] [stdout] 837 |                         converted.map_err(|err| err.into())
[INFO] [stdout]     |                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/types/tuple.rs:81:1
[INFO] [stdout]     |
[INFO] [stdout]  81 | into_rust_by_index!(Tuple, Decimal);
[INFO] [stdout]     | ----------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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/macros.rs:837:49
[INFO] [stdout]     |
[INFO] [stdout] 767 | macro_rules! into_rust_by_index {
[INFO] [stdout] ...
[INFO] [stdout] 837 |                         converted.map_err(|err| err.into())
[INFO] [stdout]     |                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/types/tuple.rs:82:1
[INFO] [stdout]     |
[INFO] [stdout]  82 | into_rust_by_index!(Tuple, NaiveDateTime);
[INFO] [stdout]     | ----------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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/macros.rs:837:49
[INFO] [stdout]     |
[INFO] [stdout] 767 | macro_rules! into_rust_by_index {
[INFO] [stdout] ...
[INFO] [stdout] 837 |                         converted.map_err(|err| err.into())
[INFO] [stdout]     |                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/types/tuple.rs:83:1
[INFO] [stdout]     |
[INFO] [stdout]  83 | into_rust_by_index!(Tuple, DateTime<Utc>);
[INFO] [stdout]     | ----------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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/macros.rs:837:49
[INFO] [stdout]     |
[INFO] [stdout] 767 | macro_rules! into_rust_by_index {
[INFO] [stdout] ...
[INFO] [stdout] 837 |                         converted.map_err(|err| err.into())
[INFO] [stdout]     |                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/types/tuple.rs:84:1
[INFO] [stdout]     |
[INFO] [stdout]  84 | into_rust_by_index!(Tuple, BigInt);
[INFO] [stdout]     | ---------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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/macros.rs:760:49
[INFO] [stdout]     |
[INFO] [stdout] 618 | macro_rules! into_rust_by_name {
[INFO] [stdout] ...
[INFO] [stdout] 760 |                         converted.map_err(|err| err.into())
[INFO] [stdout]     |                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/types/udt.rs:44:1
[INFO] [stdout]     |
[INFO] [stdout]  44 | into_rust_by_name!(Udt, Blob);
[INFO] [stdout]     | ----------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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/macros.rs:760:49
[INFO] [stdout]     |
[INFO] [stdout] 618 | macro_rules! into_rust_by_name {
[INFO] [stdout] ...
[INFO] [stdout] 760 |                         converted.map_err(|err| err.into())
[INFO] [stdout]     |                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/types/udt.rs:45:1
[INFO] [stdout]     |
[INFO] [stdout]  45 | into_rust_by_name!(Udt, 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/macros.rs:760:49
[INFO] [stdout]     |
[INFO] [stdout] 618 | macro_rules! into_rust_by_name {
[INFO] [stdout] ...
[INFO] [stdout] 760 |                         converted.map_err(|err| err.into())
[INFO] [stdout]     |                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/types/udt.rs:46:1
[INFO] [stdout]     |
[INFO] [stdout]  46 | into_rust_by_name!(Udt, bool);
[INFO] [stdout]     | ----------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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/macros.rs:760:49
[INFO] [stdout]     |
[INFO] [stdout] 618 | macro_rules! into_rust_by_name {
[INFO] [stdout] ...
[INFO] [stdout] 760 |                         converted.map_err(|err| err.into())
[INFO] [stdout]     |                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/types/udt.rs:47:1
[INFO] [stdout]     |
[INFO] [stdout]  47 | into_rust_by_name!(Udt, i64);
[INFO] [stdout]     | ---------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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/macros.rs:760:49
[INFO] [stdout]     |
[INFO] [stdout] 618 | macro_rules! into_rust_by_name {
[INFO] [stdout] ...
[INFO] [stdout] 760 |                         converted.map_err(|err| err.into())
[INFO] [stdout]     |                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/types/udt.rs:48:1
[INFO] [stdout]     |
[INFO] [stdout]  48 | into_rust_by_name!(Udt, 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/macros.rs:760:49
[INFO] [stdout]     |
[INFO] [stdout] 618 | macro_rules! into_rust_by_name {
[INFO] [stdout] ...
[INFO] [stdout] 760 |                         converted.map_err(|err| err.into())
[INFO] [stdout]     |                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/types/udt.rs:49:1
[INFO] [stdout]     |
[INFO] [stdout]  49 | into_rust_by_name!(Udt, i16);
[INFO] [stdout]     | ---------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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/macros.rs:760:49
[INFO] [stdout]     |
[INFO] [stdout] 618 | macro_rules! into_rust_by_name {
[INFO] [stdout] ...
[INFO] [stdout] 760 |                         converted.map_err(|err| err.into())
[INFO] [stdout]     |                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/types/udt.rs:50:1
[INFO] [stdout]     |
[INFO] [stdout]  50 | into_rust_by_name!(Udt, i8);
[INFO] [stdout]     | --------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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/macros.rs:760:49
[INFO] [stdout]     |
[INFO] [stdout] 618 | macro_rules! into_rust_by_name {
[INFO] [stdout] ...
[INFO] [stdout] 760 |                         converted.map_err(|err| err.into())
[INFO] [stdout]     |                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/types/udt.rs:51:1
[INFO] [stdout]     |
[INFO] [stdout]  51 | into_rust_by_name!(Udt, f64);
[INFO] [stdout]     | ---------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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/macros.rs:760:49
[INFO] [stdout]     |
[INFO] [stdout] 618 | macro_rules! into_rust_by_name {
[INFO] [stdout] ...
[INFO] [stdout] 760 |                         converted.map_err(|err| err.into())
[INFO] [stdout]     |                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/types/udt.rs:52:1
[INFO] [stdout]     |
[INFO] [stdout]  52 | into_rust_by_name!(Udt, f32);
[INFO] [stdout]     | ---------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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/macros.rs:760:49
[INFO] [stdout]     |
[INFO] [stdout] 618 | macro_rules! into_rust_by_name {
[INFO] [stdout] ...
[INFO] [stdout] 760 |                         converted.map_err(|err| err.into())
[INFO] [stdout]     |                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/types/udt.rs:53:1
[INFO] [stdout]     |
[INFO] [stdout]  53 | into_rust_by_name!(Udt, IpAddr);
[INFO] [stdout]     | ------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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/macros.rs:760:49
[INFO] [stdout]     |
[INFO] [stdout] 618 | macro_rules! into_rust_by_name {
[INFO] [stdout] ...
[INFO] [stdout] 760 |                         converted.map_err(|err| err.into())
[INFO] [stdout]     |                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/types/udt.rs:54:1
[INFO] [stdout]     |
[INFO] [stdout]  54 | into_rust_by_name!(Udt, Uuid);
[INFO] [stdout]     | ----------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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/macros.rs:705:49
[INFO] [stdout]     |
[INFO] [stdout] 618 | macro_rules! into_rust_by_name {
[INFO] [stdout] ...
[INFO] [stdout] 705 |                         converted.map_err(|err| err.into())
[INFO] [stdout]     |                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/types/udt.rs:55:1
[INFO] [stdout]     |
[INFO] [stdout]  55 | into_rust_by_name!(Udt, List);
[INFO] [stdout]     | ----------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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/macros.rs:719:49
[INFO] [stdout]     |
[INFO] [stdout] 618 | macro_rules! into_rust_by_name {
[INFO] [stdout] ...
[INFO] [stdout] 719 |                         converted.map_err(|err| err.into())
[INFO] [stdout]     |                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/types/udt.rs:56:1
[INFO] [stdout]     |
[INFO] [stdout]  56 | into_rust_by_name!(Udt, Map);
[INFO] [stdout]     | ---------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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/macros.rs:733:49
[INFO] [stdout]     |
[INFO] [stdout] 618 | macro_rules! into_rust_by_name {
[INFO] [stdout] ...
[INFO] [stdout] 733 |                         converted.map_err(|err| err.into())
[INFO] [stdout]     |                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/types/udt.rs:57:1
[INFO] [stdout]     |
[INFO] [stdout]  57 | into_rust_by_name!(Udt, Udt);
[INFO] [stdout]     | ---------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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/macros.rs:747:49
[INFO] [stdout]     |
[INFO] [stdout] 618 | macro_rules! into_rust_by_name {
[INFO] [stdout] ...
[INFO] [stdout] 747 |                         converted.map_err(|err| err.into())
[INFO] [stdout]     |                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/types/udt.rs:58:1
[INFO] [stdout]     |
[INFO] [stdout]  58 | into_rust_by_name!(Udt, Tuple);
[INFO] [stdout]     | ------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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/macros.rs:760:49
[INFO] [stdout]     |
[INFO] [stdout] 618 | macro_rules! into_rust_by_name {
[INFO] [stdout] ...
[INFO] [stdout] 760 |                         converted.map_err(|err| err.into())
[INFO] [stdout]     |                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/types/udt.rs:59:1
[INFO] [stdout]     |
[INFO] [stdout]  59 | into_rust_by_name!(Udt, PrimitiveDateTime);
[INFO] [stdout]     | ------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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/macros.rs:760:49
[INFO] [stdout]     |
[INFO] [stdout] 618 | macro_rules! into_rust_by_name {
[INFO] [stdout] ...
[INFO] [stdout] 760 |                         converted.map_err(|err| err.into())
[INFO] [stdout]     |                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/types/udt.rs:60:1
[INFO] [stdout]     |
[INFO] [stdout]  60 | into_rust_by_name!(Udt, Decimal);
[INFO] [stdout]     | -------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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/macros.rs:760:49
[INFO] [stdout]     |
[INFO] [stdout] 618 | macro_rules! into_rust_by_name {
[INFO] [stdout] ...
[INFO] [stdout] 760 |                         converted.map_err(|err| err.into())
[INFO] [stdout]     |                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/types/udt.rs:61:1
[INFO] [stdout]     |
[INFO] [stdout]  61 | into_rust_by_name!(Udt, NonZeroI8);
[INFO] [stdout]     | ---------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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/macros.rs:760:49
[INFO] [stdout]     |
[INFO] [stdout] 618 | macro_rules! into_rust_by_name {
[INFO] [stdout] ...
[INFO] [stdout] 760 |                         converted.map_err(|err| err.into())
[INFO] [stdout]     |                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/types/udt.rs:62:1
[INFO] [stdout]     |
[INFO] [stdout]  62 | into_rust_by_name!(Udt, NonZeroI16);
[INFO] [stdout]     | ----------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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/macros.rs:760:49
[INFO] [stdout]     |
[INFO] [stdout] 618 | macro_rules! into_rust_by_name {
[INFO] [stdout] ...
[INFO] [stdout] 760 |                         converted.map_err(|err| err.into())
[INFO] [stdout]     |                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/types/udt.rs:63:1
[INFO] [stdout]     |
[INFO] [stdout]  63 | into_rust_by_name!(Udt, NonZeroI32);
[INFO] [stdout]     | ----------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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/macros.rs:760:49
[INFO] [stdout]     |
[INFO] [stdout] 618 | macro_rules! into_rust_by_name {
[INFO] [stdout] ...
[INFO] [stdout] 760 |                         converted.map_err(|err| err.into())
[INFO] [stdout]     |                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/types/udt.rs:64:1
[INFO] [stdout]     |
[INFO] [stdout]  64 | into_rust_by_name!(Udt, NonZeroI64);
[INFO] [stdout]     | ----------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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/macros.rs:760:49
[INFO] [stdout]     |
[INFO] [stdout] 618 | macro_rules! into_rust_by_name {
[INFO] [stdout] ...
[INFO] [stdout] 760 |                         converted.map_err(|err| err.into())
[INFO] [stdout]     |                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/types/udt.rs:65:1
[INFO] [stdout]     |
[INFO] [stdout]  65 | into_rust_by_name!(Udt, NaiveDateTime);
[INFO] [stdout]     | -------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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/macros.rs:760:49
[INFO] [stdout]     |
[INFO] [stdout] 618 | macro_rules! into_rust_by_name {
[INFO] [stdout] ...
[INFO] [stdout] 760 |                         converted.map_err(|err| err.into())
[INFO] [stdout]     |                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/types/udt.rs:66:1
[INFO] [stdout]     |
[INFO] [stdout]  66 | into_rust_by_name!(Udt, DateTime<Utc>);
[INFO] [stdout]     | -------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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/macros.rs:760:49
[INFO] [stdout]     |
[INFO] [stdout] 618 | macro_rules! into_rust_by_name {
[INFO] [stdout] ...
[INFO] [stdout] 760 |                         converted.map_err(|err| err.into())
[INFO] [stdout]     |                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/types/udt.rs:67:1
[INFO] [stdout]     |
[INFO] [stdout]  67 | into_rust_by_name!(Udt, BigInt);
[INFO] [stdout]     | ------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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 `cassandra-protocol` (lib) due to 44 previous errors
[INFO] [stderr] warning: build failed, waiting for other jobs to finish...
[INFO] [stdout] error: useless conversion to the same type: `error::Error`
[INFO] [stdout]    --> src/macros.rs:837:49
[INFO] [stdout]     |
[INFO] [stdout] 767 | macro_rules! into_rust_by_index {
[INFO] [stdout] ...
[INFO] [stdout] 837 |                         converted.map_err(|err| err.into())
[INFO] [stdout]     |                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/types/tuple.rs:65:1
[INFO] [stdout]     |
[INFO] [stdout]  65 | into_rust_by_index!(Tuple, Blob);
[INFO] [stdout]     | -------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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/macros.rs:837:49
[INFO] [stdout]     |
[INFO] [stdout] 767 | macro_rules! into_rust_by_index {
[INFO] [stdout] ...
[INFO] [stdout] 837 |                         converted.map_err(|err| err.into())
[INFO] [stdout]     |                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/types/tuple.rs:66:1
[INFO] [stdout]     |
[INFO] [stdout]  66 | into_rust_by_index!(Tuple, 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/macros.rs:837:49
[INFO] [stdout]     |
[INFO] [stdout] 767 | macro_rules! into_rust_by_index {
[INFO] [stdout] ...
[INFO] [stdout] 837 |                         converted.map_err(|err| err.into())
[INFO] [stdout]     |                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/types/tuple.rs:67:1
[INFO] [stdout]     |
[INFO] [stdout]  67 | into_rust_by_index!(Tuple, bool);
[INFO] [stdout]     | -------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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/macros.rs:837:49
[INFO] [stdout]     |
[INFO] [stdout] 767 | macro_rules! into_rust_by_index {
[INFO] [stdout] ...
[INFO] [stdout] 837 |                         converted.map_err(|err| err.into())
[INFO] [stdout]     |                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/types/tuple.rs:68:1
[INFO] [stdout]     |
[INFO] [stdout]  68 | into_rust_by_index!(Tuple, i64);
[INFO] [stdout]     | ------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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/macros.rs:837:49
[INFO] [stdout]     |
[INFO] [stdout] 767 | macro_rules! into_rust_by_index {
[INFO] [stdout] ...
[INFO] [stdout] 837 |                         converted.map_err(|err| err.into())
[INFO] [stdout]     |                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/types/tuple.rs:69:1
[INFO] [stdout]     |
[INFO] [stdout]  69 | into_rust_by_index!(Tuple, 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/macros.rs:837:49
[INFO] [stdout]     |
[INFO] [stdout] 767 | macro_rules! into_rust_by_index {
[INFO] [stdout] ...
[INFO] [stdout] 837 |                         converted.map_err(|err| err.into())
[INFO] [stdout]     |                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/types/tuple.rs:70:1
[INFO] [stdout]     |
[INFO] [stdout]  70 | into_rust_by_index!(Tuple, i16);
[INFO] [stdout]     | ------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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/macros.rs:837:49
[INFO] [stdout]     |
[INFO] [stdout] 767 | macro_rules! into_rust_by_index {
[INFO] [stdout] ...
[INFO] [stdout] 837 |                         converted.map_err(|err| err.into())
[INFO] [stdout]     |                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/types/tuple.rs:71:1
[INFO] [stdout]     |
[INFO] [stdout]  71 | into_rust_by_index!(Tuple, i8);
[INFO] [stdout]     | ------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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/macros.rs:837:49
[INFO] [stdout]     |
[INFO] [stdout] 767 | macro_rules! into_rust_by_index {
[INFO] [stdout] ...
[INFO] [stdout] 837 |                         converted.map_err(|err| err.into())
[INFO] [stdout]     |                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/types/tuple.rs:72:1
[INFO] [stdout]     |
[INFO] [stdout]  72 | into_rust_by_index!(Tuple, f64);
[INFO] [stdout]     | ------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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/macros.rs:837:49
[INFO] [stdout]     |
[INFO] [stdout] 767 | macro_rules! into_rust_by_index {
[INFO] [stdout] ...
[INFO] [stdout] 837 |                         converted.map_err(|err| err.into())
[INFO] [stdout]     |                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/types/tuple.rs:73:1
[INFO] [stdout]     |
[INFO] [stdout]  73 | into_rust_by_index!(Tuple, f32);
[INFO] [stdout]     | ------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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/macros.rs:837:49
[INFO] [stdout]     |
[INFO] [stdout] 767 | macro_rules! into_rust_by_index {
[INFO] [stdout] ...
[INFO] [stdout] 837 |                         converted.map_err(|err| err.into())
[INFO] [stdout]     |                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/types/tuple.rs:74:1
[INFO] [stdout]     |
[INFO] [stdout]  74 | into_rust_by_index!(Tuple, IpAddr);
[INFO] [stdout]     | ---------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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/macros.rs:837:49
[INFO] [stdout]     |
[INFO] [stdout] 767 | macro_rules! into_rust_by_index {
[INFO] [stdout] ...
[INFO] [stdout] 837 |                         converted.map_err(|err| err.into())
[INFO] [stdout]     |                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/types/tuple.rs:75:1
[INFO] [stdout]     |
[INFO] [stdout]  75 | into_rust_by_index!(Tuple, Uuid);
[INFO] [stdout]     | -------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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/macros.rs:778:49
[INFO] [stdout]     |
[INFO] [stdout] 767 | macro_rules! into_rust_by_index {
[INFO] [stdout] ...
[INFO] [stdout] 778 |                         converted.map_err(|err| err.into())
[INFO] [stdout]     |                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/types/tuple.rs:76:1
[INFO] [stdout]     |
[INFO] [stdout]  76 | into_rust_by_index!(Tuple, List);
[INFO] [stdout]     | -------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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/macros.rs:793:49
[INFO] [stdout]     |
[INFO] [stdout] 767 | macro_rules! into_rust_by_index {
[INFO] [stdout] ...
[INFO] [stdout] 793 |                         converted.map_err(|err| err.into())
[INFO] [stdout]     |                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/types/tuple.rs:77:1
[INFO] [stdout]     |
[INFO] [stdout]  77 | into_rust_by_index!(Tuple, Map);
[INFO] [stdout]     | ------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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/macros.rs:808:49
[INFO] [stdout]     |
[INFO] [stdout] 767 | macro_rules! into_rust_by_index {
[INFO] [stdout] ...
[INFO] [stdout] 808 |                         converted.map_err(|err| err.into())
[INFO] [stdout]     |                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/types/tuple.rs:78:1
[INFO] [stdout]     |
[INFO] [stdout]  78 | into_rust_by_index!(Tuple, Udt);
[INFO] [stdout]     | ------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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/macros.rs:823:49
[INFO] [stdout]     |
[INFO] [stdout] 767 | macro_rules! into_rust_by_index {
[INFO] [stdout] ...
[INFO] [stdout] 823 |                         converted.map_err(|err| err.into())
[INFO] [stdout]     |                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/types/tuple.rs:79:1
[INFO] [stdout]     |
[INFO] [stdout]  79 | into_rust_by_index!(Tuple, Tuple);
[INFO] [stdout]     | --------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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/macros.rs:837:49
[INFO] [stdout]     |
[INFO] [stdout] 767 | macro_rules! into_rust_by_index {
[INFO] [stdout] ...
[INFO] [stdout] 837 |                         converted.map_err(|err| err.into())
[INFO] [stdout]     |                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/types/tuple.rs:80:1
[INFO] [stdout]     |
[INFO] [stdout]  80 | into_rust_by_index!(Tuple, PrimitiveDateTime);
[INFO] [stdout]     | --------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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/macros.rs:837:49
[INFO] [stdout]     |
[INFO] [stdout] 767 | macro_rules! into_rust_by_index {
[INFO] [stdout] ...
[INFO] [stdout] 837 |                         converted.map_err(|err| err.into())
[INFO] [stdout]     |                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/types/tuple.rs:81:1
[INFO] [stdout]     |
[INFO] [stdout]  81 | into_rust_by_index!(Tuple, Decimal);
[INFO] [stdout]     | ----------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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/macros.rs:837:49
[INFO] [stdout]     |
[INFO] [stdout] 767 | macro_rules! into_rust_by_index {
[INFO] [stdout] ...
[INFO] [stdout] 837 |                         converted.map_err(|err| err.into())
[INFO] [stdout]     |                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/types/tuple.rs:82:1
[INFO] [stdout]     |
[INFO] [stdout]  82 | into_rust_by_index!(Tuple, NaiveDateTime);
[INFO] [stdout]     | ----------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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/macros.rs:837:49
[INFO] [stdout]     |
[INFO] [stdout] 767 | macro_rules! into_rust_by_index {
[INFO] [stdout] ...
[INFO] [stdout] 837 |                         converted.map_err(|err| err.into())
[INFO] [stdout]     |                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/types/tuple.rs:83:1
[INFO] [stdout]     |
[INFO] [stdout]  83 | into_rust_by_index!(Tuple, DateTime<Utc>);
[INFO] [stdout]     | ----------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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/macros.rs:837:49
[INFO] [stdout]     |
[INFO] [stdout] 767 | macro_rules! into_rust_by_index {
[INFO] [stdout] ...
[INFO] [stdout] 837 |                         converted.map_err(|err| err.into())
[INFO] [stdout]     |                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/types/tuple.rs:84:1
[INFO] [stdout]     |
[INFO] [stdout]  84 | into_rust_by_index!(Tuple, BigInt);
[INFO] [stdout]     | ---------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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/macros.rs:760:49
[INFO] [stdout]     |
[INFO] [stdout] 618 | macro_rules! into_rust_by_name {
[INFO] [stdout] ...
[INFO] [stdout] 760 |                         converted.map_err(|err| err.into())
[INFO] [stdout]     |                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/types/udt.rs:44:1
[INFO] [stdout]     |
[INFO] [stdout]  44 | into_rust_by_name!(Udt, Blob);
[INFO] [stdout]     | ----------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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/macros.rs:760:49
[INFO] [stdout]     |
[INFO] [stdout] 618 | macro_rules! into_rust_by_name {
[INFO] [stdout] ...
[INFO] [stdout] 760 |                         converted.map_err(|err| err.into())
[INFO] [stdout]     |                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/types/udt.rs:45:1
[INFO] [stdout]     |
[INFO] [stdout]  45 | into_rust_by_name!(Udt, 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/macros.rs:760:49
[INFO] [stdout]     |
[INFO] [stdout] 618 | macro_rules! into_rust_by_name {
[INFO] [stdout] ...
[INFO] [stdout] 760 |                         converted.map_err(|err| err.into())
[INFO] [stdout]     |                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/types/udt.rs:46:1
[INFO] [stdout]     |
[INFO] [stdout]  46 | into_rust_by_name!(Udt, bool);
[INFO] [stdout]     | ----------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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/macros.rs:760:49
[INFO] [stdout]     |
[INFO] [stdout] 618 | macro_rules! into_rust_by_name {
[INFO] [stdout] ...
[INFO] [stdout] 760 |                         converted.map_err(|err| err.into())
[INFO] [stdout]     |                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/types/udt.rs:47:1
[INFO] [stdout]     |
[INFO] [stdout]  47 | into_rust_by_name!(Udt, i64);
[INFO] [stdout]     | ---------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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/macros.rs:760:49
[INFO] [stdout]     |
[INFO] [stdout] 618 | macro_rules! into_rust_by_name {
[INFO] [stdout] ...
[INFO] [stdout] 760 |                         converted.map_err(|err| err.into())
[INFO] [stdout]     |                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/types/udt.rs:48:1
[INFO] [stdout]     |
[INFO] [stdout]  48 | into_rust_by_name!(Udt, 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/macros.rs:760:49
[INFO] [stdout]     |
[INFO] [stdout] 618 | macro_rules! into_rust_by_name {
[INFO] [stdout] ...
[INFO] [stdout] 760 |                         converted.map_err(|err| err.into())
[INFO] [stdout]     |                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/types/udt.rs:49:1
[INFO] [stdout]     |
[INFO] [stdout]  49 | into_rust_by_name!(Udt, i16);
[INFO] [stdout]     | ---------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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/macros.rs:760:49
[INFO] [stdout]     |
[INFO] [stdout] 618 | macro_rules! into_rust_by_name {
[INFO] [stdout] ...
[INFO] [stdout] 760 |                         converted.map_err(|err| err.into())
[INFO] [stdout]     |                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/types/udt.rs:50:1
[INFO] [stdout]     |
[INFO] [stdout]  50 | into_rust_by_name!(Udt, i8);
[INFO] [stdout]     | --------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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/macros.rs:760:49
[INFO] [stdout]     |
[INFO] [stdout] 618 | macro_rules! into_rust_by_name {
[INFO] [stdout] ...
[INFO] [stdout] 760 |                         converted.map_err(|err| err.into())
[INFO] [stdout]     |                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/types/udt.rs:51:1
[INFO] [stdout]     |
[INFO] [stdout]  51 | into_rust_by_name!(Udt, f64);
[INFO] [stdout]     | ---------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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/macros.rs:760:49
[INFO] [stdout]     |
[INFO] [stdout] 618 | macro_rules! into_rust_by_name {
[INFO] [stdout] ...
[INFO] [stdout] 760 |                         converted.map_err(|err| err.into())
[INFO] [stdout]     |                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/types/udt.rs:52:1
[INFO] [stdout]     |
[INFO] [stdout]  52 | into_rust_by_name!(Udt, f32);
[INFO] [stdout]     | ---------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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/macros.rs:760:49
[INFO] [stdout]     |
[INFO] [stdout] 618 | macro_rules! into_rust_by_name {
[INFO] [stdout] ...
[INFO] [stdout] 760 |                         converted.map_err(|err| err.into())
[INFO] [stdout]     |                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/types/udt.rs:53:1
[INFO] [stdout]     |
[INFO] [stdout]  53 | into_rust_by_name!(Udt, IpAddr);
[INFO] [stdout]     | ------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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/macros.rs:760:49
[INFO] [stdout]     |
[INFO] [stdout] 618 | macro_rules! into_rust_by_name {
[INFO] [stdout] ...
[INFO] [stdout] 760 |                         converted.map_err(|err| err.into())
[INFO] [stdout]     |                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/types/udt.rs:54:1
[INFO] [stdout]     |
[INFO] [stdout]  54 | into_rust_by_name!(Udt, Uuid);
[INFO] [stdout]     | ----------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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/macros.rs:705:49
[INFO] [stdout]     |
[INFO] [stdout] 618 | macro_rules! into_rust_by_name {
[INFO] [stdout] ...
[INFO] [stdout] 705 |                         converted.map_err(|err| err.into())
[INFO] [stdout]     |                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/types/udt.rs:55:1
[INFO] [stdout]     |
[INFO] [stdout]  55 | into_rust_by_name!(Udt, List);
[INFO] [stdout]     | ----------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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/macros.rs:719:49
[INFO] [stdout]     |
[INFO] [stdout] 618 | macro_rules! into_rust_by_name {
[INFO] [stdout] ...
[INFO] [stdout] 719 |                         converted.map_err(|err| err.into())
[INFO] [stdout]     |                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/types/udt.rs:56:1
[INFO] [stdout]     |
[INFO] [stdout]  56 | into_rust_by_name!(Udt, Map);
[INFO] [stdout]     | ---------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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/macros.rs:733:49
[INFO] [stdout]     |
[INFO] [stdout] 618 | macro_rules! into_rust_by_name {
[INFO] [stdout] ...
[INFO] [stdout] 733 |                         converted.map_err(|err| err.into())
[INFO] [stdout]     |                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/types/udt.rs:57:1
[INFO] [stdout]     |
[INFO] [stdout]  57 | into_rust_by_name!(Udt, Udt);
[INFO] [stdout]     | ---------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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/macros.rs:747:49
[INFO] [stdout]     |
[INFO] [stdout] 618 | macro_rules! into_rust_by_name {
[INFO] [stdout] ...
[INFO] [stdout] 747 |                         converted.map_err(|err| err.into())
[INFO] [stdout]     |                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/types/udt.rs:58:1
[INFO] [stdout]     |
[INFO] [stdout]  58 | into_rust_by_name!(Udt, Tuple);
[INFO] [stdout]     | ------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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/macros.rs:760:49
[INFO] [stdout]     |
[INFO] [stdout] 618 | macro_rules! into_rust_by_name {
[INFO] [stdout] ...
[INFO] [stdout] 760 |                         converted.map_err(|err| err.into())
[INFO] [stdout]     |                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/types/udt.rs:59:1
[INFO] [stdout]     |
[INFO] [stdout]  59 | into_rust_by_name!(Udt, PrimitiveDateTime);
[INFO] [stdout]     | ------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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/macros.rs:760:49
[INFO] [stdout]     |
[INFO] [stdout] 618 | macro_rules! into_rust_by_name {
[INFO] [stdout] ...
[INFO] [stdout] 760 |                         converted.map_err(|err| err.into())
[INFO] [stdout]     |                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/types/udt.rs:60:1
[INFO] [stdout]     |
[INFO] [stdout]  60 | into_rust_by_name!(Udt, Decimal);
[INFO] [stdout]     | -------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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/macros.rs:760:49
[INFO] [stdout]     |
[INFO] [stdout] 618 | macro_rules! into_rust_by_name {
[INFO] [stdout] ...
[INFO] [stdout] 760 |                         converted.map_err(|err| err.into())
[INFO] [stdout]     |                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/types/udt.rs:61:1
[INFO] [stdout]     |
[INFO] [stdout]  61 | into_rust_by_name!(Udt, NonZeroI8);
[INFO] [stdout]     | ---------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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/macros.rs:760:49
[INFO] [stdout]     |
[INFO] [stdout] 618 | macro_rules! into_rust_by_name {
[INFO] [stdout] ...
[INFO] [stdout] 760 |                         converted.map_err(|err| err.into())
[INFO] [stdout]     |                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/types/udt.rs:62:1
[INFO] [stdout]     |
[INFO] [stdout]  62 | into_rust_by_name!(Udt, NonZeroI16);
[INFO] [stdout]     | ----------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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/macros.rs:760:49
[INFO] [stdout]     |
[INFO] [stdout] 618 | macro_rules! into_rust_by_name {
[INFO] [stdout] ...
[INFO] [stdout] 760 |                         converted.map_err(|err| err.into())
[INFO] [stdout]     |                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/types/udt.rs:63:1
[INFO] [stdout]     |
[INFO] [stdout]  63 | into_rust_by_name!(Udt, NonZeroI32);
[INFO] [stdout]     | ----------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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/macros.rs:760:49
[INFO] [stdout]     |
[INFO] [stdout] 618 | macro_rules! into_rust_by_name {
[INFO] [stdout] ...
[INFO] [stdout] 760 |                         converted.map_err(|err| err.into())
[INFO] [stdout]     |                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/types/udt.rs:64:1
[INFO] [stdout]     |
[INFO] [stdout]  64 | into_rust_by_name!(Udt, NonZeroI64);
[INFO] [stdout]     | ----------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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/macros.rs:760:49
[INFO] [stdout]     |
[INFO] [stdout] 618 | macro_rules! into_rust_by_name {
[INFO] [stdout] ...
[INFO] [stdout] 760 |                         converted.map_err(|err| err.into())
[INFO] [stdout]     |                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/types/udt.rs:65:1
[INFO] [stdout]     |
[INFO] [stdout]  65 | into_rust_by_name!(Udt, NaiveDateTime);
[INFO] [stdout]     | -------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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/macros.rs:760:49
[INFO] [stdout]     |
[INFO] [stdout] 618 | macro_rules! into_rust_by_name {
[INFO] [stdout] ...
[INFO] [stdout] 760 |                         converted.map_err(|err| err.into())
[INFO] [stdout]     |                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/types/udt.rs:66:1
[INFO] [stdout]     |
[INFO] [stdout]  66 | into_rust_by_name!(Udt, DateTime<Utc>);
[INFO] [stdout]     | -------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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/macros.rs:760:49
[INFO] [stdout]     |
[INFO] [stdout] 618 | macro_rules! into_rust_by_name {
[INFO] [stdout] ...
[INFO] [stdout] 760 |                         converted.map_err(|err| err.into())
[INFO] [stdout]     |                                                 ^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/types/udt.rs:67:1
[INFO] [stdout]     |
[INFO] [stdout]  67 | into_rust_by_name!(Udt, BigInt);
[INFO] [stdout]     | ------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that 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 `cassandra-protocol` (lib test) due to 44 previous errors
[INFO] running `Command { std: "docker" "inspect" "f92e0ba97a6348c80dbb35745938487905ebb775fd644289e8745dc595b73429", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "f92e0ba97a6348c80dbb35745938487905ebb775fd644289e8745dc595b73429", kill_on_drop: false }`
[INFO] [stdout] f92e0ba97a6348c80dbb35745938487905ebb775fd644289e8745dc595b73429
