[INFO] fetching crate malachite-bigint 0.14.0...
[INFO] checking malachite-bigint-0.14.0 against 52995a223f2919dd3e2e427231db90a257350ded for pr-129249-4
[INFO] extracting crate malachite-bigint 0.14.0 into /workspace/builds/worker-4-tc2/source
[INFO] started tweaking crates.io crate malachite-bigint 0.14.0
[INFO] finished tweaking crates.io crate malachite-bigint 0.14.0
[INFO] tweaked toml for crates.io crate malachite-bigint 0.14.0 written to /workspace/builds/worker-4-tc2/source/Cargo.toml
[INFO] validating manifest of crates.io crate malachite-bigint 0.14.0 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 malachite-bigint 0.14.0 already has a lockfile, it will not be regenerated
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+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:77db811e55d90add9212f6832c23229e3de5f1c1f9905e8cb07319ea15df73ac" "sleep" "infinity", kill_on_drop: false }`
[INFO] [stdout] 1d5e7781367860d0384b6a0d1af0a68385d1ad5799205d90def4c953d7fc9b60
[INFO] running `Command { std: "docker" "start" "1d5e7781367860d0384b6a0d1af0a68385d1ad5799205d90def4c953d7fc9b60", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "1d5e7781367860d0384b6a0d1af0a68385d1ad5799205d90def4c953d7fc9b60", 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" "1d5e7781367860d0384b6a0d1af0a68385d1ad5799205d90def4c953d7fc9b60" "/opt/rustwide/cargo-home/bin/cargo" "+52995a223f2919dd3e2e427231db90a257350ded" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "1d5e7781367860d0384b6a0d1af0a68385d1ad5799205d90def4c953d7fc9b60", 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" "1d5e7781367860d0384b6a0d1af0a68385d1ad5799205d90def4c953d7fc9b60" "/opt/rustwide/cargo-home/bin/cargo" "+52995a223f2919dd3e2e427231db90a257350ded" "check" "--frozen" "--all" "--all-targets" "--message-format=json", kill_on_drop: false }`
[INFO] [stderr]    Compiling libm v0.2.16
[INFO] [stderr]    Compiling malachite-nz v0.14.0
[INFO] [stderr]     Checking safe_arch v1.2.0
[INFO] [stderr]     Checking hashbrown v0.16.1
[INFO] [stderr]     Checking itertools v0.14.0
[INFO] [stderr]     Checking wide v1.7.1
[INFO] [stderr]     Checking malachite-base v0.14.0
[INFO] [stderr]     Checking malachite-bigint v0.14.0 (/opt/rustwide/workdir)
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:248:49
[INFO] [stdout]     |
[INFO] [stdout] 241 | macro_rules! forward_assign_self {
[INFO] [stdout] ...
[INFO] [stdout] 248 |             |lhs: &mut $struct, rhs: $struct| { $trait::$fn(&mut lhs.0, rhs.0).into() }
[INFO] [stdout]     |                                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:98:1
[INFO] [stdout]     |
[INFO] [stdout]  98 | forward_assign_self!(BigInt, AddAssign, add_assign);
[INFO] [stdout]     | --------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::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: `()`
[INFO] [stdout]    --> src/macros.rs:255:50
[INFO] [stdout]     |
[INFO] [stdout] 241 | macro_rules! forward_assign_self {
[INFO] [stdout] ...
[INFO] [stdout] 255 |             |lhs: &mut $struct, rhs: &$struct| { $trait::$fn(&mut lhs.0, &rhs.0).into() }
[INFO] [stdout]     |                                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:98:1
[INFO] [stdout]     |
[INFO] [stdout]  98 | forward_assign_self!(BigInt, AddAssign, add_assign);
[INFO] [stdout]     | --------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:248:85
[INFO] [stdout]     |
[INFO] [stdout] 241 | macro_rules! forward_assign_self {
[INFO] [stdout] ...
[INFO] [stdout] 248 |             |lhs: &mut $struct, rhs: $struct| { $trait::$fn(&mut lhs.0, rhs.0).into() }
[INFO] [stdout]     |                                                                                     ^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:99:1
[INFO] [stdout]     |
[INFO] [stdout]  99 | forward_assign_self!(BigInt, SubAssign, sub_assign);
[INFO] [stdout]     | --------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:255:87
[INFO] [stdout]     |
[INFO] [stdout] 241 | macro_rules! forward_assign_self {
[INFO] [stdout] ...
[INFO] [stdout] 255 |             |lhs: &mut $struct, rhs: &$struct| { $trait::$fn(&mut lhs.0, &rhs.0).into() }
[INFO] [stdout]     |                                                                                       ^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:99:1
[INFO] [stdout]     |
[INFO] [stdout]  99 | forward_assign_self!(BigInt, SubAssign, sub_assign);
[INFO] [stdout]     | --------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:248:85
[INFO] [stdout]     |
[INFO] [stdout] 241 | macro_rules! forward_assign_self {
[INFO] [stdout] ...
[INFO] [stdout] 248 |             |lhs: &mut $struct, rhs: $struct| { $trait::$fn(&mut lhs.0, rhs.0).into() }
[INFO] [stdout]     |                                                                                     ^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:100:1
[INFO] [stdout]     |
[INFO] [stdout] 100 | forward_assign_self!(BigInt, MulAssign, mul_assign);
[INFO] [stdout]     | --------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:255:87
[INFO] [stdout]     |
[INFO] [stdout] 241 | macro_rules! forward_assign_self {
[INFO] [stdout] ...
[INFO] [stdout] 255 |             |lhs: &mut $struct, rhs: &$struct| { $trait::$fn(&mut lhs.0, &rhs.0).into() }
[INFO] [stdout]     |                                                                                       ^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:100:1
[INFO] [stdout]     |
[INFO] [stdout] 100 | forward_assign_self!(BigInt, MulAssign, mul_assign);
[INFO] [stdout]     | --------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:248:85
[INFO] [stdout]     |
[INFO] [stdout] 241 | macro_rules! forward_assign_self {
[INFO] [stdout] ...
[INFO] [stdout] 248 |             |lhs: &mut $struct, rhs: $struct| { $trait::$fn(&mut lhs.0, rhs.0).into() }
[INFO] [stdout]     |                                                                                     ^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:101:1
[INFO] [stdout]     |
[INFO] [stdout] 101 | forward_assign_self!(BigInt, DivAssign, div_assign);
[INFO] [stdout]     | --------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:255:87
[INFO] [stdout]     |
[INFO] [stdout] 241 | macro_rules! forward_assign_self {
[INFO] [stdout] ...
[INFO] [stdout] 255 |             |lhs: &mut $struct, rhs: &$struct| { $trait::$fn(&mut lhs.0, &rhs.0).into() }
[INFO] [stdout]     |                                                                                       ^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:101:1
[INFO] [stdout]     |
[INFO] [stdout] 101 | forward_assign_self!(BigInt, DivAssign, div_assign);
[INFO] [stdout]     | --------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:248:85
[INFO] [stdout]     |
[INFO] [stdout] 241 | macro_rules! forward_assign_self {
[INFO] [stdout] ...
[INFO] [stdout] 248 |             |lhs: &mut $struct, rhs: $struct| { $trait::$fn(&mut lhs.0, rhs.0).into() }
[INFO] [stdout]     |                                                                                     ^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:102:1
[INFO] [stdout]     |
[INFO] [stdout] 102 | forward_assign_self!(BigInt, RemAssign, rem_assign);
[INFO] [stdout]     | --------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:255:87
[INFO] [stdout]     |
[INFO] [stdout] 241 | macro_rules! forward_assign_self {
[INFO] [stdout] ...
[INFO] [stdout] 255 |             |lhs: &mut $struct, rhs: &$struct| { $trait::$fn(&mut lhs.0, &rhs.0).into() }
[INFO] [stdout]     |                                                                                       ^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:102:1
[INFO] [stdout]     |
[INFO] [stdout] 102 | forward_assign_self!(BigInt, RemAssign, rem_assign);
[INFO] [stdout]     | --------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:248:85
[INFO] [stdout]     |
[INFO] [stdout] 241 | macro_rules! forward_assign_self {
[INFO] [stdout] ...
[INFO] [stdout] 248 |             |lhs: &mut $struct, rhs: $struct| { $trait::$fn(&mut lhs.0, rhs.0).into() }
[INFO] [stdout]     |                                                                                     ^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:103:1
[INFO] [stdout]     |
[INFO] [stdout] 103 | forward_assign_self!(BigInt, BitAndAssign, bitand_assign);
[INFO] [stdout]     | --------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:255:87
[INFO] [stdout]     |
[INFO] [stdout] 241 | macro_rules! forward_assign_self {
[INFO] [stdout] ...
[INFO] [stdout] 255 |             |lhs: &mut $struct, rhs: &$struct| { $trait::$fn(&mut lhs.0, &rhs.0).into() }
[INFO] [stdout]     |                                                                                       ^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:103:1
[INFO] [stdout]     |
[INFO] [stdout] 103 | forward_assign_self!(BigInt, BitAndAssign, bitand_assign);
[INFO] [stdout]     | --------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:248:85
[INFO] [stdout]     |
[INFO] [stdout] 241 | macro_rules! forward_assign_self {
[INFO] [stdout] ...
[INFO] [stdout] 248 |             |lhs: &mut $struct, rhs: $struct| { $trait::$fn(&mut lhs.0, rhs.0).into() }
[INFO] [stdout]     |                                                                                     ^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:104:1
[INFO] [stdout]     |
[INFO] [stdout] 104 | forward_assign_self!(BigInt, BitOrAssign, bitor_assign);
[INFO] [stdout]     | ------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:255:87
[INFO] [stdout]     |
[INFO] [stdout] 241 | macro_rules! forward_assign_self {
[INFO] [stdout] ...
[INFO] [stdout] 255 |             |lhs: &mut $struct, rhs: &$struct| { $trait::$fn(&mut lhs.0, &rhs.0).into() }
[INFO] [stdout]     |                                                                                       ^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:104:1
[INFO] [stdout]     |
[INFO] [stdout] 104 | forward_assign_self!(BigInt, BitOrAssign, bitor_assign);
[INFO] [stdout]     | ------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:248:85
[INFO] [stdout]     |
[INFO] [stdout] 241 | macro_rules! forward_assign_self {
[INFO] [stdout] ...
[INFO] [stdout] 248 |             |lhs: &mut $struct, rhs: $struct| { $trait::$fn(&mut lhs.0, rhs.0).into() }
[INFO] [stdout]     |                                                                                     ^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:105:1
[INFO] [stdout]     |
[INFO] [stdout] 105 | forward_assign_self!(BigInt, BitXorAssign, bitxor_assign);
[INFO] [stdout]     | --------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:255:87
[INFO] [stdout]     |
[INFO] [stdout] 241 | macro_rules! forward_assign_self {
[INFO] [stdout] ...
[INFO] [stdout] 255 |             |lhs: &mut $struct, rhs: &$struct| { $trait::$fn(&mut lhs.0, &rhs.0).into() }
[INFO] [stdout]     |                                                                                       ^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:105:1
[INFO] [stdout]     |
[INFO] [stdout] 105 | forward_assign_self!(BigInt, BitXorAssign, bitxor_assign);
[INFO] [stdout]     | --------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:248:85
[INFO] [stdout]     |
[INFO] [stdout] 241 | macro_rules! forward_assign_self {
[INFO] [stdout] ...
[INFO] [stdout] 248 |             |lhs: &mut $struct, rhs: $struct| { $trait::$fn(&mut lhs.0, rhs.0).into() }
[INFO] [stdout]     |                                                                                     ^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:70:1
[INFO] [stdout]     |
[INFO] [stdout]  70 | forward_assign_self!(BigUint, AddAssign, add_assign);
[INFO] [stdout]     | ---------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:255:87
[INFO] [stdout]     |
[INFO] [stdout] 241 | macro_rules! forward_assign_self {
[INFO] [stdout] ...
[INFO] [stdout] 255 |             |lhs: &mut $struct, rhs: &$struct| { $trait::$fn(&mut lhs.0, &rhs.0).into() }
[INFO] [stdout]     |                                                                                       ^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:70:1
[INFO] [stdout]     |
[INFO] [stdout]  70 | forward_assign_self!(BigUint, AddAssign, add_assign);
[INFO] [stdout]     | ---------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:248:85
[INFO] [stdout]     |
[INFO] [stdout] 241 | macro_rules! forward_assign_self {
[INFO] [stdout] ...
[INFO] [stdout] 248 |             |lhs: &mut $struct, rhs: $struct| { $trait::$fn(&mut lhs.0, rhs.0).into() }
[INFO] [stdout]     |                                                                                     ^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:71:1
[INFO] [stdout]     |
[INFO] [stdout]  71 | forward_assign_self!(BigUint, SubAssign, sub_assign);
[INFO] [stdout]     | ---------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:255:87
[INFO] [stdout]     |
[INFO] [stdout] 241 | macro_rules! forward_assign_self {
[INFO] [stdout] ...
[INFO] [stdout] 255 |             |lhs: &mut $struct, rhs: &$struct| { $trait::$fn(&mut lhs.0, &rhs.0).into() }
[INFO] [stdout]     |                                                                                       ^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:71:1
[INFO] [stdout]     |
[INFO] [stdout]  71 | forward_assign_self!(BigUint, SubAssign, sub_assign);
[INFO] [stdout]     | ---------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:248:85
[INFO] [stdout]     |
[INFO] [stdout] 241 | macro_rules! forward_assign_self {
[INFO] [stdout] ...
[INFO] [stdout] 248 |             |lhs: &mut $struct, rhs: $struct| { $trait::$fn(&mut lhs.0, rhs.0).into() }
[INFO] [stdout]     |                                                                                     ^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:72:1
[INFO] [stdout]     |
[INFO] [stdout]  72 | forward_assign_self!(BigUint, MulAssign, mul_assign);
[INFO] [stdout]     | ---------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:255:87
[INFO] [stdout]     |
[INFO] [stdout] 241 | macro_rules! forward_assign_self {
[INFO] [stdout] ...
[INFO] [stdout] 255 |             |lhs: &mut $struct, rhs: &$struct| { $trait::$fn(&mut lhs.0, &rhs.0).into() }
[INFO] [stdout]     |                                                                                       ^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:72:1
[INFO] [stdout]     |
[INFO] [stdout]  72 | forward_assign_self!(BigUint, MulAssign, mul_assign);
[INFO] [stdout]     | ---------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:248:85
[INFO] [stdout]     |
[INFO] [stdout] 241 | macro_rules! forward_assign_self {
[INFO] [stdout] ...
[INFO] [stdout] 248 |             |lhs: &mut $struct, rhs: $struct| { $trait::$fn(&mut lhs.0, rhs.0).into() }
[INFO] [stdout]     |                                                                                     ^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:73:1
[INFO] [stdout]     |
[INFO] [stdout]  73 | forward_assign_self!(BigUint, DivAssign, div_assign);
[INFO] [stdout]     | ---------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:255:87
[INFO] [stdout]     |
[INFO] [stdout] 241 | macro_rules! forward_assign_self {
[INFO] [stdout] ...
[INFO] [stdout] 255 |             |lhs: &mut $struct, rhs: &$struct| { $trait::$fn(&mut lhs.0, &rhs.0).into() }
[INFO] [stdout]     |                                                                                       ^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:73:1
[INFO] [stdout]     |
[INFO] [stdout]  73 | forward_assign_self!(BigUint, DivAssign, div_assign);
[INFO] [stdout]     | ---------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:248:85
[INFO] [stdout]     |
[INFO] [stdout] 241 | macro_rules! forward_assign_self {
[INFO] [stdout] ...
[INFO] [stdout] 248 |             |lhs: &mut $struct, rhs: $struct| { $trait::$fn(&mut lhs.0, rhs.0).into() }
[INFO] [stdout]     |                                                                                     ^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:74:1
[INFO] [stdout]     |
[INFO] [stdout]  74 | forward_assign_self!(BigUint, RemAssign, rem_assign);
[INFO] [stdout]     | ---------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:255:87
[INFO] [stdout]     |
[INFO] [stdout] 241 | macro_rules! forward_assign_self {
[INFO] [stdout] ...
[INFO] [stdout] 255 |             |lhs: &mut $struct, rhs: &$struct| { $trait::$fn(&mut lhs.0, &rhs.0).into() }
[INFO] [stdout]     |                                                                                       ^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:74:1
[INFO] [stdout]     |
[INFO] [stdout]  74 | forward_assign_self!(BigUint, RemAssign, rem_assign);
[INFO] [stdout]     | ---------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:248:85
[INFO] [stdout]     |
[INFO] [stdout] 241 | macro_rules! forward_assign_self {
[INFO] [stdout] ...
[INFO] [stdout] 248 |             |lhs: &mut $struct, rhs: $struct| { $trait::$fn(&mut lhs.0, rhs.0).into() }
[INFO] [stdout]     |                                                                                     ^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:75:1
[INFO] [stdout]     |
[INFO] [stdout]  75 | forward_assign_self!(BigUint, BitAndAssign, bitand_assign);
[INFO] [stdout]     | ---------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:255:87
[INFO] [stdout]     |
[INFO] [stdout] 241 | macro_rules! forward_assign_self {
[INFO] [stdout] ...
[INFO] [stdout] 255 |             |lhs: &mut $struct, rhs: &$struct| { $trait::$fn(&mut lhs.0, &rhs.0).into() }
[INFO] [stdout]     |                                                                                       ^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:75:1
[INFO] [stdout]     |
[INFO] [stdout]  75 | forward_assign_self!(BigUint, BitAndAssign, bitand_assign);
[INFO] [stdout]     | ---------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:248:85
[INFO] [stdout]     |
[INFO] [stdout] 241 | macro_rules! forward_assign_self {
[INFO] [stdout] ...
[INFO] [stdout] 248 |             |lhs: &mut $struct, rhs: $struct| { $trait::$fn(&mut lhs.0, rhs.0).into() }
[INFO] [stdout]     |                                                                                     ^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:76:1
[INFO] [stdout]     |
[INFO] [stdout]  76 | forward_assign_self!(BigUint, BitOrAssign, bitor_assign);
[INFO] [stdout]     | -------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:255:87
[INFO] [stdout]     |
[INFO] [stdout] 241 | macro_rules! forward_assign_self {
[INFO] [stdout] ...
[INFO] [stdout] 255 |             |lhs: &mut $struct, rhs: &$struct| { $trait::$fn(&mut lhs.0, &rhs.0).into() }
[INFO] [stdout]     |                                                                                       ^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:76:1
[INFO] [stdout]     |
[INFO] [stdout]  76 | forward_assign_self!(BigUint, BitOrAssign, bitor_assign);
[INFO] [stdout]     | -------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:248:85
[INFO] [stdout]     |
[INFO] [stdout] 241 | macro_rules! forward_assign_self {
[INFO] [stdout] ...
[INFO] [stdout] 248 |             |lhs: &mut $struct, rhs: $struct| { $trait::$fn(&mut lhs.0, rhs.0).into() }
[INFO] [stdout]     |                                                                                     ^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:77:1
[INFO] [stdout]     |
[INFO] [stdout]  77 | forward_assign_self!(BigUint, BitXorAssign, bitxor_assign);
[INFO] [stdout]     | ---------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:255:87
[INFO] [stdout]     |
[INFO] [stdout] 241 | macro_rules! forward_assign_self {
[INFO] [stdout] ...
[INFO] [stdout] 255 |             |lhs: &mut $struct, rhs: &$struct| { $trait::$fn(&mut lhs.0, &rhs.0).into() }
[INFO] [stdout]     |                                                                                       ^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:77:1
[INFO] [stdout]     |
[INFO] [stdout]  77 | forward_assign_self!(BigUint, BitXorAssign, bitxor_assign);
[INFO] [stdout]     | ---------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:13
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:124:1
[INFO] [stdout]     |
[INFO] [stdout] 124 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, AddAssign, add_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:13
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:124:1
[INFO] [stdout]     |
[INFO] [stdout] 124 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, AddAssign, add_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:124:1
[INFO] [stdout]     |
[INFO] [stdout] 124 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, AddAssign, add_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:124:1
[INFO] [stdout]     |
[INFO] [stdout] 124 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, AddAssign, add_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:124:1
[INFO] [stdout]     |
[INFO] [stdout] 124 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, AddAssign, add_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:124:1
[INFO] [stdout]     |
[INFO] [stdout] 124 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, AddAssign, add_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:124:1
[INFO] [stdout]     |
[INFO] [stdout] 124 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, AddAssign, add_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:124:1
[INFO] [stdout]     |
[INFO] [stdout] 124 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, AddAssign, add_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:124:1
[INFO] [stdout]     |
[INFO] [stdout] 124 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, AddAssign, add_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:124:1
[INFO] [stdout]     |
[INFO] [stdout] 124 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, AddAssign, add_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:124:1
[INFO] [stdout]     |
[INFO] [stdout] 124 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, AddAssign, add_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:124:1
[INFO] [stdout]     |
[INFO] [stdout] 124 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, AddAssign, add_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:124:1
[INFO] [stdout]     |
[INFO] [stdout] 124 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, AddAssign, add_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:124:1
[INFO] [stdout]     |
[INFO] [stdout] 124 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, AddAssign, add_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:124:1
[INFO] [stdout]     |
[INFO] [stdout] 124 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, AddAssign, add_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:124:1
[INFO] [stdout]     |
[INFO] [stdout] 124 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, AddAssign, add_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:124:1
[INFO] [stdout]     |
[INFO] [stdout] 124 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, AddAssign, add_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:124:1
[INFO] [stdout]     |
[INFO] [stdout] 124 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, AddAssign, add_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:124:1
[INFO] [stdout]     |
[INFO] [stdout] 124 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, AddAssign, add_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:124:1
[INFO] [stdout]     |
[INFO] [stdout] 124 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, AddAssign, add_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:124:1
[INFO] [stdout]     |
[INFO] [stdout] 124 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, AddAssign, add_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:124:1
[INFO] [stdout]     |
[INFO] [stdout] 124 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, AddAssign, add_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:124:1
[INFO] [stdout]     |
[INFO] [stdout] 124 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, AddAssign, add_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:124:1
[INFO] [stdout]     |
[INFO] [stdout] 124 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, AddAssign, add_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:125:1
[INFO] [stdout]     |
[INFO] [stdout] 125 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, SubAssign, sub_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:125:1
[INFO] [stdout]     |
[INFO] [stdout] 125 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, SubAssign, sub_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:125:1
[INFO] [stdout]     |
[INFO] [stdout] 125 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, SubAssign, sub_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:125:1
[INFO] [stdout]     |
[INFO] [stdout] 125 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, SubAssign, sub_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:125:1
[INFO] [stdout]     |
[INFO] [stdout] 125 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, SubAssign, sub_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:125:1
[INFO] [stdout]     |
[INFO] [stdout] 125 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, SubAssign, sub_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:125:1
[INFO] [stdout]     |
[INFO] [stdout] 125 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, SubAssign, sub_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:125:1
[INFO] [stdout]     |
[INFO] [stdout] 125 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, SubAssign, sub_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:125:1
[INFO] [stdout]     |
[INFO] [stdout] 125 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, SubAssign, sub_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:125:1
[INFO] [stdout]     |
[INFO] [stdout] 125 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, SubAssign, sub_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:125:1
[INFO] [stdout]     |
[INFO] [stdout] 125 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, SubAssign, sub_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:125:1
[INFO] [stdout]     |
[INFO] [stdout] 125 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, SubAssign, sub_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:125:1
[INFO] [stdout]     |
[INFO] [stdout] 125 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, SubAssign, sub_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:125:1
[INFO] [stdout]     |
[INFO] [stdout] 125 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, SubAssign, sub_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:125:1
[INFO] [stdout]     |
[INFO] [stdout] 125 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, SubAssign, sub_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:125:1
[INFO] [stdout]     |
[INFO] [stdout] 125 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, SubAssign, sub_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:125:1
[INFO] [stdout]     |
[INFO] [stdout] 125 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, SubAssign, sub_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:125:1
[INFO] [stdout]     |
[INFO] [stdout] 125 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, SubAssign, sub_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:125:1
[INFO] [stdout]     |
[INFO] [stdout] 125 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, SubAssign, sub_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:125:1
[INFO] [stdout]     |
[INFO] [stdout] 125 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, SubAssign, sub_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:125:1
[INFO] [stdout]     |
[INFO] [stdout] 125 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, SubAssign, sub_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:125:1
[INFO] [stdout]     |
[INFO] [stdout] 125 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, SubAssign, sub_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:125:1
[INFO] [stdout]     |
[INFO] [stdout] 125 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, SubAssign, sub_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:125:1
[INFO] [stdout]     |
[INFO] [stdout] 125 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, SubAssign, sub_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:126:1
[INFO] [stdout]     |
[INFO] [stdout] 126 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, MulAssign, mul_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:126:1
[INFO] [stdout]     |
[INFO] [stdout] 126 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, MulAssign, mul_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:126:1
[INFO] [stdout]     |
[INFO] [stdout] 126 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, MulAssign, mul_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:126:1
[INFO] [stdout]     |
[INFO] [stdout] 126 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, MulAssign, mul_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:126:1
[INFO] [stdout]     |
[INFO] [stdout] 126 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, MulAssign, mul_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:126:1
[INFO] [stdout]     |
[INFO] [stdout] 126 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, MulAssign, mul_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:126:1
[INFO] [stdout]     |
[INFO] [stdout] 126 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, MulAssign, mul_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:126:1
[INFO] [stdout]     |
[INFO] [stdout] 126 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, MulAssign, mul_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:126:1
[INFO] [stdout]     |
[INFO] [stdout] 126 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, MulAssign, mul_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:126:1
[INFO] [stdout]     |
[INFO] [stdout] 126 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, MulAssign, mul_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:126:1
[INFO] [stdout]     |
[INFO] [stdout] 126 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, MulAssign, mul_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:126:1
[INFO] [stdout]     |
[INFO] [stdout] 126 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, MulAssign, mul_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:126:1
[INFO] [stdout]     |
[INFO] [stdout] 126 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, MulAssign, mul_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:126:1
[INFO] [stdout]     |
[INFO] [stdout] 126 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, MulAssign, mul_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:126:1
[INFO] [stdout]     |
[INFO] [stdout] 126 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, MulAssign, mul_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:126:1
[INFO] [stdout]     |
[INFO] [stdout] 126 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, MulAssign, mul_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:126:1
[INFO] [stdout]     |
[INFO] [stdout] 126 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, MulAssign, mul_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:126:1
[INFO] [stdout]     |
[INFO] [stdout] 126 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, MulAssign, mul_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:126:1
[INFO] [stdout]     |
[INFO] [stdout] 126 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, MulAssign, mul_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:126:1
[INFO] [stdout]     |
[INFO] [stdout] 126 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, MulAssign, mul_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:126:1
[INFO] [stdout]     |
[INFO] [stdout] 126 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, MulAssign, mul_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:126:1
[INFO] [stdout]     |
[INFO] [stdout] 126 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, MulAssign, mul_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:126:1
[INFO] [stdout]     |
[INFO] [stdout] 126 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, MulAssign, mul_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:126:1
[INFO] [stdout]     |
[INFO] [stdout] 126 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, MulAssign, mul_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:127:1
[INFO] [stdout]     |
[INFO] [stdout] 127 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, DivAssign, div_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:127:1
[INFO] [stdout]     |
[INFO] [stdout] 127 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, DivAssign, div_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:127:1
[INFO] [stdout]     |
[INFO] [stdout] 127 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, DivAssign, div_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:127:1
[INFO] [stdout]     |
[INFO] [stdout] 127 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, DivAssign, div_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:127:1
[INFO] [stdout]     |
[INFO] [stdout] 127 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, DivAssign, div_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:127:1
[INFO] [stdout]     |
[INFO] [stdout] 127 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, DivAssign, div_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:127:1
[INFO] [stdout]     |
[INFO] [stdout] 127 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, DivAssign, div_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:127:1
[INFO] [stdout]     |
[INFO] [stdout] 127 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, DivAssign, div_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:127:1
[INFO] [stdout]     |
[INFO] [stdout] 127 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, DivAssign, div_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:127:1
[INFO] [stdout]     |
[INFO] [stdout] 127 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, DivAssign, div_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:127:1
[INFO] [stdout]     |
[INFO] [stdout] 127 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, DivAssign, div_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:127:1
[INFO] [stdout]     |
[INFO] [stdout] 127 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, DivAssign, div_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:127:1
[INFO] [stdout]     |
[INFO] [stdout] 127 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, DivAssign, div_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:127:1
[INFO] [stdout]     |
[INFO] [stdout] 127 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, DivAssign, div_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:127:1
[INFO] [stdout]     |
[INFO] [stdout] 127 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, DivAssign, div_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:127:1
[INFO] [stdout]     |
[INFO] [stdout] 127 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, DivAssign, div_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:127:1
[INFO] [stdout]     |
[INFO] [stdout] 127 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, DivAssign, div_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:127:1
[INFO] [stdout]     |
[INFO] [stdout] 127 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, DivAssign, div_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:127:1
[INFO] [stdout]     |
[INFO] [stdout] 127 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, DivAssign, div_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:127:1
[INFO] [stdout]     |
[INFO] [stdout] 127 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, DivAssign, div_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:127:1
[INFO] [stdout]     |
[INFO] [stdout] 127 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, DivAssign, div_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:127:1
[INFO] [stdout]     |
[INFO] [stdout] 127 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, DivAssign, div_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:127:1
[INFO] [stdout]     |
[INFO] [stdout] 127 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, DivAssign, div_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:127:1
[INFO] [stdout]     |
[INFO] [stdout] 127 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, DivAssign, div_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:128:1
[INFO] [stdout]     |
[INFO] [stdout] 128 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, RemAssign, rem_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:128:1
[INFO] [stdout]     |
[INFO] [stdout] 128 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, RemAssign, rem_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:128:1
[INFO] [stdout]     |
[INFO] [stdout] 128 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, RemAssign, rem_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:128:1
[INFO] [stdout]     |
[INFO] [stdout] 128 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, RemAssign, rem_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:128:1
[INFO] [stdout]     |
[INFO] [stdout] 128 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, RemAssign, rem_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:128:1
[INFO] [stdout]     |
[INFO] [stdout] 128 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, RemAssign, rem_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:128:1
[INFO] [stdout]     |
[INFO] [stdout] 128 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, RemAssign, rem_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:128:1
[INFO] [stdout]     |
[INFO] [stdout] 128 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, RemAssign, rem_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:128:1
[INFO] [stdout]     |
[INFO] [stdout] 128 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, RemAssign, rem_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:128:1
[INFO] [stdout]     |
[INFO] [stdout] 128 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, RemAssign, rem_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:128:1
[INFO] [stdout]     |
[INFO] [stdout] 128 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, RemAssign, rem_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:128:1
[INFO] [stdout]     |
[INFO] [stdout] 128 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, RemAssign, rem_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:128:1
[INFO] [stdout]     |
[INFO] [stdout] 128 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, RemAssign, rem_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:128:1
[INFO] [stdout]     |
[INFO] [stdout] 128 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, RemAssign, rem_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:128:1
[INFO] [stdout]     |
[INFO] [stdout] 128 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, RemAssign, rem_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:128:1
[INFO] [stdout]     |
[INFO] [stdout] 128 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, RemAssign, rem_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:128:1
[INFO] [stdout]     |
[INFO] [stdout] 128 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, RemAssign, rem_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:128:1
[INFO] [stdout]     |
[INFO] [stdout] 128 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, RemAssign, rem_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:128:1
[INFO] [stdout]     |
[INFO] [stdout] 128 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, RemAssign, rem_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:128:1
[INFO] [stdout]     |
[INFO] [stdout] 128 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, RemAssign, rem_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:128:1
[INFO] [stdout]     |
[INFO] [stdout] 128 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, RemAssign, rem_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:128:1
[INFO] [stdout]     |
[INFO] [stdout] 128 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, RemAssign, rem_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:128:1
[INFO] [stdout]     |
[INFO] [stdout] 128 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, RemAssign, rem_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:128:1
[INFO] [stdout]     |
[INFO] [stdout] 128 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, RemAssign, rem_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_unsigneds`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:96:1
[INFO] [stdout]     |
[INFO] [stdout]  96 |   apply_to_unsigneds!(forward_assign_primitive_into{BigUint, _, AddAssign, add_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_unsigneds`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:96:1
[INFO] [stdout]     |
[INFO] [stdout]  96 |   apply_to_unsigneds!(forward_assign_primitive_into{BigUint, _, AddAssign, add_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_unsigneds`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:96:1
[INFO] [stdout]     |
[INFO] [stdout]  96 |   apply_to_unsigneds!(forward_assign_primitive_into{BigUint, _, AddAssign, add_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_unsigneds`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:96:1
[INFO] [stdout]     |
[INFO] [stdout]  96 |   apply_to_unsigneds!(forward_assign_primitive_into{BigUint, _, AddAssign, add_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_unsigneds`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:96:1
[INFO] [stdout]     |
[INFO] [stdout]  96 |   apply_to_unsigneds!(forward_assign_primitive_into{BigUint, _, AddAssign, add_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_unsigneds`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:96:1
[INFO] [stdout]     |
[INFO] [stdout]  96 |   apply_to_unsigneds!(forward_assign_primitive_into{BigUint, _, AddAssign, add_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_unsigneds`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:96:1
[INFO] [stdout]     |
[INFO] [stdout]  96 |   apply_to_unsigneds!(forward_assign_primitive_into{BigUint, _, AddAssign, add_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_unsigneds`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:96:1
[INFO] [stdout]     |
[INFO] [stdout]  96 |   apply_to_unsigneds!(forward_assign_primitive_into{BigUint, _, AddAssign, add_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_unsigneds`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:96:1
[INFO] [stdout]     |
[INFO] [stdout]  96 |   apply_to_unsigneds!(forward_assign_primitive_into{BigUint, _, AddAssign, add_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_unsigneds`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:96:1
[INFO] [stdout]     |
[INFO] [stdout]  96 |   apply_to_unsigneds!(forward_assign_primitive_into{BigUint, _, AddAssign, add_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_unsigneds`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:96:1
[INFO] [stdout]     |
[INFO] [stdout]  96 |   apply_to_unsigneds!(forward_assign_primitive_into{BigUint, _, AddAssign, add_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_unsigneds`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:96:1
[INFO] [stdout]     |
[INFO] [stdout]  96 |   apply_to_unsigneds!(forward_assign_primitive_into{BigUint, _, AddAssign, add_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_unsigneds`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:97:1
[INFO] [stdout]     |
[INFO] [stdout]  97 |   apply_to_unsigneds!(forward_assign_primitive_into{BigUint, _, SubAssign, sub_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_unsigneds`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:97:1
[INFO] [stdout]     |
[INFO] [stdout]  97 |   apply_to_unsigneds!(forward_assign_primitive_into{BigUint, _, SubAssign, sub_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_unsigneds`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:97:1
[INFO] [stdout]     |
[INFO] [stdout]  97 |   apply_to_unsigneds!(forward_assign_primitive_into{BigUint, _, SubAssign, sub_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_unsigneds`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:97:1
[INFO] [stdout]     |
[INFO] [stdout]  97 |   apply_to_unsigneds!(forward_assign_primitive_into{BigUint, _, SubAssign, sub_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_unsigneds`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:97:1
[INFO] [stdout]     |
[INFO] [stdout]  97 |   apply_to_unsigneds!(forward_assign_primitive_into{BigUint, _, SubAssign, sub_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_unsigneds`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:97:1
[INFO] [stdout]     |
[INFO] [stdout]  97 |   apply_to_unsigneds!(forward_assign_primitive_into{BigUint, _, SubAssign, sub_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_unsigneds`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:97:1
[INFO] [stdout]     |
[INFO] [stdout]  97 |   apply_to_unsigneds!(forward_assign_primitive_into{BigUint, _, SubAssign, sub_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_unsigneds`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:97:1
[INFO] [stdout]     |
[INFO] [stdout]  97 |   apply_to_unsigneds!(forward_assign_primitive_into{BigUint, _, SubAssign, sub_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_unsigneds`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:97:1
[INFO] [stdout]     |
[INFO] [stdout]  97 |   apply_to_unsigneds!(forward_assign_primitive_into{BigUint, _, SubAssign, sub_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_unsigneds`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:97:1
[INFO] [stdout]     |
[INFO] [stdout]  97 |   apply_to_unsigneds!(forward_assign_primitive_into{BigUint, _, SubAssign, sub_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_unsigneds`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:97:1
[INFO] [stdout]     |
[INFO] [stdout]  97 |   apply_to_unsigneds!(forward_assign_primitive_into{BigUint, _, SubAssign, sub_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_unsigneds`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:97:1
[INFO] [stdout]     |
[INFO] [stdout]  97 |   apply_to_unsigneds!(forward_assign_primitive_into{BigUint, _, SubAssign, sub_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_unsigneds`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:98:1
[INFO] [stdout]     |
[INFO] [stdout]  98 |   apply_to_unsigneds!(forward_assign_primitive_into{BigUint, _, MulAssign, mul_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_unsigneds`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:98:1
[INFO] [stdout]     |
[INFO] [stdout]  98 |   apply_to_unsigneds!(forward_assign_primitive_into{BigUint, _, MulAssign, mul_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_unsigneds`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:98:1
[INFO] [stdout]     |
[INFO] [stdout]  98 |   apply_to_unsigneds!(forward_assign_primitive_into{BigUint, _, MulAssign, mul_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_unsigneds`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:98:1
[INFO] [stdout]     |
[INFO] [stdout]  98 |   apply_to_unsigneds!(forward_assign_primitive_into{BigUint, _, MulAssign, mul_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_unsigneds`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:98:1
[INFO] [stdout]     |
[INFO] [stdout]  98 |   apply_to_unsigneds!(forward_assign_primitive_into{BigUint, _, MulAssign, mul_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_unsigneds`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:98:1
[INFO] [stdout]     |
[INFO] [stdout]  98 |   apply_to_unsigneds!(forward_assign_primitive_into{BigUint, _, MulAssign, mul_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_unsigneds`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:98:1
[INFO] [stdout]     |
[INFO] [stdout]  98 |   apply_to_unsigneds!(forward_assign_primitive_into{BigUint, _, MulAssign, mul_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_unsigneds`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:98:1
[INFO] [stdout]     |
[INFO] [stdout]  98 |   apply_to_unsigneds!(forward_assign_primitive_into{BigUint, _, MulAssign, mul_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_unsigneds`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:98:1
[INFO] [stdout]     |
[INFO] [stdout]  98 |   apply_to_unsigneds!(forward_assign_primitive_into{BigUint, _, MulAssign, mul_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_unsigneds`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:98:1
[INFO] [stdout]     |
[INFO] [stdout]  98 |   apply_to_unsigneds!(forward_assign_primitive_into{BigUint, _, MulAssign, mul_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_unsigneds`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:98:1
[INFO] [stdout]     |
[INFO] [stdout]  98 |   apply_to_unsigneds!(forward_assign_primitive_into{BigUint, _, MulAssign, mul_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_unsigneds`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:98:1
[INFO] [stdout]     |
[INFO] [stdout]  98 |   apply_to_unsigneds!(forward_assign_primitive_into{BigUint, _, MulAssign, mul_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_unsigneds`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:99:1
[INFO] [stdout]     |
[INFO] [stdout]  99 |   apply_to_unsigneds!(forward_assign_primitive_into{BigUint, _, DivAssign, div_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_unsigneds`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:99:1
[INFO] [stdout]     |
[INFO] [stdout]  99 |   apply_to_unsigneds!(forward_assign_primitive_into{BigUint, _, DivAssign, div_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_unsigneds`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:99:1
[INFO] [stdout]     |
[INFO] [stdout]  99 |   apply_to_unsigneds!(forward_assign_primitive_into{BigUint, _, DivAssign, div_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_unsigneds`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:99:1
[INFO] [stdout]     |
[INFO] [stdout]  99 |   apply_to_unsigneds!(forward_assign_primitive_into{BigUint, _, DivAssign, div_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_unsigneds`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:99:1
[INFO] [stdout]     |
[INFO] [stdout]  99 |   apply_to_unsigneds!(forward_assign_primitive_into{BigUint, _, DivAssign, div_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_unsigneds`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:99:1
[INFO] [stdout]     |
[INFO] [stdout]  99 |   apply_to_unsigneds!(forward_assign_primitive_into{BigUint, _, DivAssign, div_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_unsigneds`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:99:1
[INFO] [stdout]     |
[INFO] [stdout]  99 |   apply_to_unsigneds!(forward_assign_primitive_into{BigUint, _, DivAssign, div_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_unsigneds`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:99:1
[INFO] [stdout]     |
[INFO] [stdout]  99 |   apply_to_unsigneds!(forward_assign_primitive_into{BigUint, _, DivAssign, div_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_unsigneds`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:99:1
[INFO] [stdout]     |
[INFO] [stdout]  99 |   apply_to_unsigneds!(forward_assign_primitive_into{BigUint, _, DivAssign, div_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_unsigneds`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:99:1
[INFO] [stdout]     |
[INFO] [stdout]  99 |   apply_to_unsigneds!(forward_assign_primitive_into{BigUint, _, DivAssign, div_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_unsigneds`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:99:1
[INFO] [stdout]     |
[INFO] [stdout]  99 |   apply_to_unsigneds!(forward_assign_primitive_into{BigUint, _, DivAssign, div_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_unsigneds`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:99:1
[INFO] [stdout]     |
[INFO] [stdout]  99 |   apply_to_unsigneds!(forward_assign_primitive_into{BigUint, _, DivAssign, div_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_unsigneds`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:100:1
[INFO] [stdout]     |
[INFO] [stdout] 100 |   apply_to_unsigneds!(forward_assign_primitive_into{BigUint, _, RemAssign, rem_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_unsigneds`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:100:1
[INFO] [stdout]     |
[INFO] [stdout] 100 |   apply_to_unsigneds!(forward_assign_primitive_into{BigUint, _, RemAssign, rem_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_unsigneds`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:100:1
[INFO] [stdout]     |
[INFO] [stdout] 100 |   apply_to_unsigneds!(forward_assign_primitive_into{BigUint, _, RemAssign, rem_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_unsigneds`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:100:1
[INFO] [stdout]     |
[INFO] [stdout] 100 |   apply_to_unsigneds!(forward_assign_primitive_into{BigUint, _, RemAssign, rem_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_unsigneds`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:100:1
[INFO] [stdout]     |
[INFO] [stdout] 100 |   apply_to_unsigneds!(forward_assign_primitive_into{BigUint, _, RemAssign, rem_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_unsigneds`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:100:1
[INFO] [stdout]     |
[INFO] [stdout] 100 |   apply_to_unsigneds!(forward_assign_primitive_into{BigUint, _, RemAssign, rem_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_unsigneds`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:100:1
[INFO] [stdout]     |
[INFO] [stdout] 100 |   apply_to_unsigneds!(forward_assign_primitive_into{BigUint, _, RemAssign, rem_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_unsigneds`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:100:1
[INFO] [stdout]     |
[INFO] [stdout] 100 |   apply_to_unsigneds!(forward_assign_primitive_into{BigUint, _, RemAssign, rem_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_unsigneds`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:100:1
[INFO] [stdout]     |
[INFO] [stdout] 100 |   apply_to_unsigneds!(forward_assign_primitive_into{BigUint, _, RemAssign, rem_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_unsigneds`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:100:1
[INFO] [stdout]     |
[INFO] [stdout] 100 |   apply_to_unsigneds!(forward_assign_primitive_into{BigUint, _, RemAssign, rem_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_unsigneds`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:100:1
[INFO] [stdout]     |
[INFO] [stdout] 100 |   apply_to_unsigneds!(forward_assign_primitive_into{BigUint, _, RemAssign, rem_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_unsigneds`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:100:1
[INFO] [stdout]     |
[INFO] [stdout] 100 |   apply_to_unsigneds!(forward_assign_primitive_into{BigUint, _, RemAssign, rem_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:263:13
[INFO] [stdout]     |
[INFO] [stdout] 260 | / macro_rules! forward_assign_primitive {
[INFO] [stdout] 261 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 262 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 263 | |             $trait::$fn(&mut lhs.0, rhs).into()
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 268 | |     };
[INFO] [stdout] 269 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:130:1
[INFO] [stdout]     |
[INFO] [stdout] 130 |   apply_to_primitives!(forward_assign_primitive{BigInt, _, ShlAssign, shl_assign});
[INFO] [stdout]     |   -------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:266:13
[INFO] [stdout]     |
[INFO] [stdout] 260 | / macro_rules! forward_assign_primitive {
[INFO] [stdout] 261 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 262 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 263 | |             $trait::$fn(&mut lhs.0, rhs).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 266 | |             $trait::$fn(&mut lhs.0, *rhs).into()
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 267 | |         });
[INFO] [stdout] 268 | |     };
[INFO] [stdout] 269 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:130:1
[INFO] [stdout]     |
[INFO] [stdout] 130 |   apply_to_primitives!(forward_assign_primitive{BigInt, _, ShlAssign, shl_assign});
[INFO] [stdout]     |   -------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:263:47
[INFO] [stdout]     |
[INFO] [stdout] 260 | / macro_rules! forward_assign_primitive {
[INFO] [stdout] 261 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 262 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 263 | |             $trait::$fn(&mut lhs.0, rhs).into()
[INFO] [stdout]     | |                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 268 | |     };
[INFO] [stdout] 269 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:130:1
[INFO] [stdout]     |
[INFO] [stdout] 130 |   apply_to_primitives!(forward_assign_primitive{BigInt, _, ShlAssign, shl_assign});
[INFO] [stdout]     |   -------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:266:48
[INFO] [stdout]     |
[INFO] [stdout] 260 | / macro_rules! forward_assign_primitive {
[INFO] [stdout] 261 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 262 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 263 | |             $trait::$fn(&mut lhs.0, rhs).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 266 | |             $trait::$fn(&mut lhs.0, *rhs).into()
[INFO] [stdout]     | |                                                ^
[INFO] [stdout] 267 | |         });
[INFO] [stdout] 268 | |     };
[INFO] [stdout] 269 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:130:1
[INFO] [stdout]     |
[INFO] [stdout] 130 |   apply_to_primitives!(forward_assign_primitive{BigInt, _, ShlAssign, shl_assign});
[INFO] [stdout]     |   -------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:263:47
[INFO] [stdout]     |
[INFO] [stdout] 260 | / macro_rules! forward_assign_primitive {
[INFO] [stdout] 261 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 262 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 263 | |             $trait::$fn(&mut lhs.0, rhs).into()
[INFO] [stdout]     | |                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 268 | |     };
[INFO] [stdout] 269 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:130:1
[INFO] [stdout]     |
[INFO] [stdout] 130 |   apply_to_primitives!(forward_assign_primitive{BigInt, _, ShlAssign, shl_assign});
[INFO] [stdout]     |   -------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:266:48
[INFO] [stdout]     |
[INFO] [stdout] 260 | / macro_rules! forward_assign_primitive {
[INFO] [stdout] 261 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 262 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 263 | |             $trait::$fn(&mut lhs.0, rhs).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 266 | |             $trait::$fn(&mut lhs.0, *rhs).into()
[INFO] [stdout]     | |                                                ^
[INFO] [stdout] 267 | |         });
[INFO] [stdout] 268 | |     };
[INFO] [stdout] 269 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:130:1
[INFO] [stdout]     |
[INFO] [stdout] 130 |   apply_to_primitives!(forward_assign_primitive{BigInt, _, ShlAssign, shl_assign});
[INFO] [stdout]     |   -------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:263:47
[INFO] [stdout]     |
[INFO] [stdout] 260 | / macro_rules! forward_assign_primitive {
[INFO] [stdout] 261 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 262 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 263 | |             $trait::$fn(&mut lhs.0, rhs).into()
[INFO] [stdout]     | |                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 268 | |     };
[INFO] [stdout] 269 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:130:1
[INFO] [stdout]     |
[INFO] [stdout] 130 |   apply_to_primitives!(forward_assign_primitive{BigInt, _, ShlAssign, shl_assign});
[INFO] [stdout]     |   -------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:266:48
[INFO] [stdout]     |
[INFO] [stdout] 260 | / macro_rules! forward_assign_primitive {
[INFO] [stdout] 261 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 262 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 263 | |             $trait::$fn(&mut lhs.0, rhs).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 266 | |             $trait::$fn(&mut lhs.0, *rhs).into()
[INFO] [stdout]     | |                                                ^
[INFO] [stdout] 267 | |         });
[INFO] [stdout] 268 | |     };
[INFO] [stdout] 269 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:130:1
[INFO] [stdout]     |
[INFO] [stdout] 130 |   apply_to_primitives!(forward_assign_primitive{BigInt, _, ShlAssign, shl_assign});
[INFO] [stdout]     |   -------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:263:47
[INFO] [stdout]     |
[INFO] [stdout] 260 | / macro_rules! forward_assign_primitive {
[INFO] [stdout] 261 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 262 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 263 | |             $trait::$fn(&mut lhs.0, rhs).into()
[INFO] [stdout]     | |                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 268 | |     };
[INFO] [stdout] 269 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:130:1
[INFO] [stdout]     |
[INFO] [stdout] 130 |   apply_to_primitives!(forward_assign_primitive{BigInt, _, ShlAssign, shl_assign});
[INFO] [stdout]     |   -------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:266:48
[INFO] [stdout]     |
[INFO] [stdout] 260 | / macro_rules! forward_assign_primitive {
[INFO] [stdout] 261 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 262 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 263 | |             $trait::$fn(&mut lhs.0, rhs).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 266 | |             $trait::$fn(&mut lhs.0, *rhs).into()
[INFO] [stdout]     | |                                                ^
[INFO] [stdout] 267 | |         });
[INFO] [stdout] 268 | |     };
[INFO] [stdout] 269 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:130:1
[INFO] [stdout]     |
[INFO] [stdout] 130 |   apply_to_primitives!(forward_assign_primitive{BigInt, _, ShlAssign, shl_assign});
[INFO] [stdout]     |   -------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:263:47
[INFO] [stdout]     |
[INFO] [stdout] 260 | / macro_rules! forward_assign_primitive {
[INFO] [stdout] 261 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 262 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 263 | |             $trait::$fn(&mut lhs.0, rhs).into()
[INFO] [stdout]     | |                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 268 | |     };
[INFO] [stdout] 269 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:130:1
[INFO] [stdout]     |
[INFO] [stdout] 130 |   apply_to_primitives!(forward_assign_primitive{BigInt, _, ShlAssign, shl_assign});
[INFO] [stdout]     |   -------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:266:48
[INFO] [stdout]     |
[INFO] [stdout] 260 | / macro_rules! forward_assign_primitive {
[INFO] [stdout] 261 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 262 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 263 | |             $trait::$fn(&mut lhs.0, rhs).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 266 | |             $trait::$fn(&mut lhs.0, *rhs).into()
[INFO] [stdout]     | |                                                ^
[INFO] [stdout] 267 | |         });
[INFO] [stdout] 268 | |     };
[INFO] [stdout] 269 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:130:1
[INFO] [stdout]     |
[INFO] [stdout] 130 |   apply_to_primitives!(forward_assign_primitive{BigInt, _, ShlAssign, shl_assign});
[INFO] [stdout]     |   -------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:263:47
[INFO] [stdout]     |
[INFO] [stdout] 260 | / macro_rules! forward_assign_primitive {
[INFO] [stdout] 261 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 262 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 263 | |             $trait::$fn(&mut lhs.0, rhs).into()
[INFO] [stdout]     | |                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 268 | |     };
[INFO] [stdout] 269 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:130:1
[INFO] [stdout]     |
[INFO] [stdout] 130 |   apply_to_primitives!(forward_assign_primitive{BigInt, _, ShlAssign, shl_assign});
[INFO] [stdout]     |   -------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:266:48
[INFO] [stdout]     |
[INFO] [stdout] 260 | / macro_rules! forward_assign_primitive {
[INFO] [stdout] 261 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 262 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 263 | |             $trait::$fn(&mut lhs.0, rhs).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 266 | |             $trait::$fn(&mut lhs.0, *rhs).into()
[INFO] [stdout]     | |                                                ^
[INFO] [stdout] 267 | |         });
[INFO] [stdout] 268 | |     };
[INFO] [stdout] 269 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:130:1
[INFO] [stdout]     |
[INFO] [stdout] 130 |   apply_to_primitives!(forward_assign_primitive{BigInt, _, ShlAssign, shl_assign});
[INFO] [stdout]     |   -------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:263:47
[INFO] [stdout]     |
[INFO] [stdout] 260 | / macro_rules! forward_assign_primitive {
[INFO] [stdout] 261 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 262 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 263 | |             $trait::$fn(&mut lhs.0, rhs).into()
[INFO] [stdout]     | |                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 268 | |     };
[INFO] [stdout] 269 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:130:1
[INFO] [stdout]     |
[INFO] [stdout] 130 |   apply_to_primitives!(forward_assign_primitive{BigInt, _, ShlAssign, shl_assign});
[INFO] [stdout]     |   -------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:266:48
[INFO] [stdout]     |
[INFO] [stdout] 260 | / macro_rules! forward_assign_primitive {
[INFO] [stdout] 261 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 262 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 263 | |             $trait::$fn(&mut lhs.0, rhs).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 266 | |             $trait::$fn(&mut lhs.0, *rhs).into()
[INFO] [stdout]     | |                                                ^
[INFO] [stdout] 267 | |         });
[INFO] [stdout] 268 | |     };
[INFO] [stdout] 269 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:130:1
[INFO] [stdout]     |
[INFO] [stdout] 130 |   apply_to_primitives!(forward_assign_primitive{BigInt, _, ShlAssign, shl_assign});
[INFO] [stdout]     |   -------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:263:47
[INFO] [stdout]     |
[INFO] [stdout] 260 | / macro_rules! forward_assign_primitive {
[INFO] [stdout] 261 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 262 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 263 | |             $trait::$fn(&mut lhs.0, rhs).into()
[INFO] [stdout]     | |                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 268 | |     };
[INFO] [stdout] 269 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:130:1
[INFO] [stdout]     |
[INFO] [stdout] 130 |   apply_to_primitives!(forward_assign_primitive{BigInt, _, ShlAssign, shl_assign});
[INFO] [stdout]     |   -------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:266:48
[INFO] [stdout]     |
[INFO] [stdout] 260 | / macro_rules! forward_assign_primitive {
[INFO] [stdout] 261 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 262 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 263 | |             $trait::$fn(&mut lhs.0, rhs).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 266 | |             $trait::$fn(&mut lhs.0, *rhs).into()
[INFO] [stdout]     | |                                                ^
[INFO] [stdout] 267 | |         });
[INFO] [stdout] 268 | |     };
[INFO] [stdout] 269 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:130:1
[INFO] [stdout]     |
[INFO] [stdout] 130 |   apply_to_primitives!(forward_assign_primitive{BigInt, _, ShlAssign, shl_assign});
[INFO] [stdout]     |   -------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:263:47
[INFO] [stdout]     |
[INFO] [stdout] 260 | / macro_rules! forward_assign_primitive {
[INFO] [stdout] 261 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 262 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 263 | |             $trait::$fn(&mut lhs.0, rhs).into()
[INFO] [stdout]     | |                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 268 | |     };
[INFO] [stdout] 269 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:130:1
[INFO] [stdout]     |
[INFO] [stdout] 130 |   apply_to_primitives!(forward_assign_primitive{BigInt, _, ShlAssign, shl_assign});
[INFO] [stdout]     |   -------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:266:48
[INFO] [stdout]     |
[INFO] [stdout] 260 | / macro_rules! forward_assign_primitive {
[INFO] [stdout] 261 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 262 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 263 | |             $trait::$fn(&mut lhs.0, rhs).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 266 | |             $trait::$fn(&mut lhs.0, *rhs).into()
[INFO] [stdout]     | |                                                ^
[INFO] [stdout] 267 | |         });
[INFO] [stdout] 268 | |     };
[INFO] [stdout] 269 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:130:1
[INFO] [stdout]     |
[INFO] [stdout] 130 |   apply_to_primitives!(forward_assign_primitive{BigInt, _, ShlAssign, shl_assign});
[INFO] [stdout]     |   -------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:263:47
[INFO] [stdout]     |
[INFO] [stdout] 260 | / macro_rules! forward_assign_primitive {
[INFO] [stdout] 261 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 262 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 263 | |             $trait::$fn(&mut lhs.0, rhs).into()
[INFO] [stdout]     | |                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 268 | |     };
[INFO] [stdout] 269 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:130:1
[INFO] [stdout]     |
[INFO] [stdout] 130 |   apply_to_primitives!(forward_assign_primitive{BigInt, _, ShlAssign, shl_assign});
[INFO] [stdout]     |   -------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:266:48
[INFO] [stdout]     |
[INFO] [stdout] 260 | / macro_rules! forward_assign_primitive {
[INFO] [stdout] 261 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 262 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 263 | |             $trait::$fn(&mut lhs.0, rhs).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 266 | |             $trait::$fn(&mut lhs.0, *rhs).into()
[INFO] [stdout]     | |                                                ^
[INFO] [stdout] 267 | |         });
[INFO] [stdout] 268 | |     };
[INFO] [stdout] 269 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:130:1
[INFO] [stdout]     |
[INFO] [stdout] 130 |   apply_to_primitives!(forward_assign_primitive{BigInt, _, ShlAssign, shl_assign});
[INFO] [stdout]     |   -------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:263:47
[INFO] [stdout]     |
[INFO] [stdout] 260 | / macro_rules! forward_assign_primitive {
[INFO] [stdout] 261 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 262 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 263 | |             $trait::$fn(&mut lhs.0, rhs).into()
[INFO] [stdout]     | |                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 268 | |     };
[INFO] [stdout] 269 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:130:1
[INFO] [stdout]     |
[INFO] [stdout] 130 |   apply_to_primitives!(forward_assign_primitive{BigInt, _, ShlAssign, shl_assign});
[INFO] [stdout]     |   -------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:266:48
[INFO] [stdout]     |
[INFO] [stdout] 260 | / macro_rules! forward_assign_primitive {
[INFO] [stdout] 261 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 262 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 263 | |             $trait::$fn(&mut lhs.0, rhs).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 266 | |             $trait::$fn(&mut lhs.0, *rhs).into()
[INFO] [stdout]     | |                                                ^
[INFO] [stdout] 267 | |         });
[INFO] [stdout] 268 | |     };
[INFO] [stdout] 269 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:130:1
[INFO] [stdout]     |
[INFO] [stdout] 130 |   apply_to_primitives!(forward_assign_primitive{BigInt, _, ShlAssign, shl_assign});
[INFO] [stdout]     |   -------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:263:47
[INFO] [stdout]     |
[INFO] [stdout] 260 | / macro_rules! forward_assign_primitive {
[INFO] [stdout] 261 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 262 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 263 | |             $trait::$fn(&mut lhs.0, rhs).into()
[INFO] [stdout]     | |                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 268 | |     };
[INFO] [stdout] 269 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:131:1
[INFO] [stdout]     |
[INFO] [stdout] 131 |   apply_to_primitives!(forward_assign_primitive{BigInt, _, ShrAssign, shr_assign});
[INFO] [stdout]     |   -------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:266:48
[INFO] [stdout]     |
[INFO] [stdout] 260 | / macro_rules! forward_assign_primitive {
[INFO] [stdout] 261 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 262 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 263 | |             $trait::$fn(&mut lhs.0, rhs).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 266 | |             $trait::$fn(&mut lhs.0, *rhs).into()
[INFO] [stdout]     | |                                                ^
[INFO] [stdout] 267 | |         });
[INFO] [stdout] 268 | |     };
[INFO] [stdout] 269 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:131:1
[INFO] [stdout]     |
[INFO] [stdout] 131 |   apply_to_primitives!(forward_assign_primitive{BigInt, _, ShrAssign, shr_assign});
[INFO] [stdout]     |   -------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:263:47
[INFO] [stdout]     |
[INFO] [stdout] 260 | / macro_rules! forward_assign_primitive {
[INFO] [stdout] 261 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 262 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 263 | |             $trait::$fn(&mut lhs.0, rhs).into()
[INFO] [stdout]     | |                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 268 | |     };
[INFO] [stdout] 269 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:131:1
[INFO] [stdout]     |
[INFO] [stdout] 131 |   apply_to_primitives!(forward_assign_primitive{BigInt, _, ShrAssign, shr_assign});
[INFO] [stdout]     |   -------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:266:48
[INFO] [stdout]     |
[INFO] [stdout] 260 | / macro_rules! forward_assign_primitive {
[INFO] [stdout] 261 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 262 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 263 | |             $trait::$fn(&mut lhs.0, rhs).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 266 | |             $trait::$fn(&mut lhs.0, *rhs).into()
[INFO] [stdout]     | |                                                ^
[INFO] [stdout] 267 | |         });
[INFO] [stdout] 268 | |     };
[INFO] [stdout] 269 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:131:1
[INFO] [stdout]     |
[INFO] [stdout] 131 |   apply_to_primitives!(forward_assign_primitive{BigInt, _, ShrAssign, shr_assign});
[INFO] [stdout]     |   -------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:263:47
[INFO] [stdout]     |
[INFO] [stdout] 260 | / macro_rules! forward_assign_primitive {
[INFO] [stdout] 261 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 262 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 263 | |             $trait::$fn(&mut lhs.0, rhs).into()
[INFO] [stdout]     | |                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 268 | |     };
[INFO] [stdout] 269 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:131:1
[INFO] [stdout]     |
[INFO] [stdout] 131 |   apply_to_primitives!(forward_assign_primitive{BigInt, _, ShrAssign, shr_assign});
[INFO] [stdout]     |   -------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:266:48
[INFO] [stdout]     |
[INFO] [stdout] 260 | / macro_rules! forward_assign_primitive {
[INFO] [stdout] 261 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 262 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 263 | |             $trait::$fn(&mut lhs.0, rhs).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 266 | |             $trait::$fn(&mut lhs.0, *rhs).into()
[INFO] [stdout]     | |                                                ^
[INFO] [stdout] 267 | |         });
[INFO] [stdout] 268 | |     };
[INFO] [stdout] 269 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:131:1
[INFO] [stdout]     |
[INFO] [stdout] 131 |   apply_to_primitives!(forward_assign_primitive{BigInt, _, ShrAssign, shr_assign});
[INFO] [stdout]     |   -------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:263:47
[INFO] [stdout]     |
[INFO] [stdout] 260 | / macro_rules! forward_assign_primitive {
[INFO] [stdout] 261 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 262 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 263 | |             $trait::$fn(&mut lhs.0, rhs).into()
[INFO] [stdout]     | |                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 268 | |     };
[INFO] [stdout] 269 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:131:1
[INFO] [stdout]     |
[INFO] [stdout] 131 |   apply_to_primitives!(forward_assign_primitive{BigInt, _, ShrAssign, shr_assign});
[INFO] [stdout]     |   -------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:266:48
[INFO] [stdout]     |
[INFO] [stdout] 260 | / macro_rules! forward_assign_primitive {
[INFO] [stdout] 261 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 262 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 263 | |             $trait::$fn(&mut lhs.0, rhs).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 266 | |             $trait::$fn(&mut lhs.0, *rhs).into()
[INFO] [stdout]     | |                                                ^
[INFO] [stdout] 267 | |         });
[INFO] [stdout] 268 | |     };
[INFO] [stdout] 269 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:131:1
[INFO] [stdout]     |
[INFO] [stdout] 131 |   apply_to_primitives!(forward_assign_primitive{BigInt, _, ShrAssign, shr_assign});
[INFO] [stdout]     |   -------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:263:47
[INFO] [stdout]     |
[INFO] [stdout] 260 | / macro_rules! forward_assign_primitive {
[INFO] [stdout] 261 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 262 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 263 | |             $trait::$fn(&mut lhs.0, rhs).into()
[INFO] [stdout]     | |                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 268 | |     };
[INFO] [stdout] 269 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:131:1
[INFO] [stdout]     |
[INFO] [stdout] 131 |   apply_to_primitives!(forward_assign_primitive{BigInt, _, ShrAssign, shr_assign});
[INFO] [stdout]     |   -------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:266:48
[INFO] [stdout]     |
[INFO] [stdout] 260 | / macro_rules! forward_assign_primitive {
[INFO] [stdout] 261 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 262 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 263 | |             $trait::$fn(&mut lhs.0, rhs).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 266 | |             $trait::$fn(&mut lhs.0, *rhs).into()
[INFO] [stdout]     | |                                                ^
[INFO] [stdout] 267 | |         });
[INFO] [stdout] 268 | |     };
[INFO] [stdout] 269 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:131:1
[INFO] [stdout]     |
[INFO] [stdout] 131 |   apply_to_primitives!(forward_assign_primitive{BigInt, _, ShrAssign, shr_assign});
[INFO] [stdout]     |   -------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:263:47
[INFO] [stdout]     |
[INFO] [stdout] 260 | / macro_rules! forward_assign_primitive {
[INFO] [stdout] 261 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 262 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 263 | |             $trait::$fn(&mut lhs.0, rhs).into()
[INFO] [stdout]     | |                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 268 | |     };
[INFO] [stdout] 269 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:131:1
[INFO] [stdout]     |
[INFO] [stdout] 131 |   apply_to_primitives!(forward_assign_primitive{BigInt, _, ShrAssign, shr_assign});
[INFO] [stdout]     |   -------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:266:48
[INFO] [stdout]     |
[INFO] [stdout] 260 | / macro_rules! forward_assign_primitive {
[INFO] [stdout] 261 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 262 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 263 | |             $trait::$fn(&mut lhs.0, rhs).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 266 | |             $trait::$fn(&mut lhs.0, *rhs).into()
[INFO] [stdout]     | |                                                ^
[INFO] [stdout] 267 | |         });
[INFO] [stdout] 268 | |     };
[INFO] [stdout] 269 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:131:1
[INFO] [stdout]     |
[INFO] [stdout] 131 |   apply_to_primitives!(forward_assign_primitive{BigInt, _, ShrAssign, shr_assign});
[INFO] [stdout]     |   -------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:263:47
[INFO] [stdout]     |
[INFO] [stdout] 260 | / macro_rules! forward_assign_primitive {
[INFO] [stdout] 261 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 262 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 263 | |             $trait::$fn(&mut lhs.0, rhs).into()
[INFO] [stdout]     | |                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 268 | |     };
[INFO] [stdout] 269 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:131:1
[INFO] [stdout]     |
[INFO] [stdout] 131 |   apply_to_primitives!(forward_assign_primitive{BigInt, _, ShrAssign, shr_assign});
[INFO] [stdout]     |   -------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:266:48
[INFO] [stdout]     |
[INFO] [stdout] 260 | / macro_rules! forward_assign_primitive {
[INFO] [stdout] 261 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 262 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 263 | |             $trait::$fn(&mut lhs.0, rhs).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 266 | |             $trait::$fn(&mut lhs.0, *rhs).into()
[INFO] [stdout]     | |                                                ^
[INFO] [stdout] 267 | |         });
[INFO] [stdout] 268 | |     };
[INFO] [stdout] 269 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:131:1
[INFO] [stdout]     |
[INFO] [stdout] 131 |   apply_to_primitives!(forward_assign_primitive{BigInt, _, ShrAssign, shr_assign});
[INFO] [stdout]     |   -------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:263:47
[INFO] [stdout]     |
[INFO] [stdout] 260 | / macro_rules! forward_assign_primitive {
[INFO] [stdout] 261 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 262 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 263 | |             $trait::$fn(&mut lhs.0, rhs).into()
[INFO] [stdout]     | |                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 268 | |     };
[INFO] [stdout] 269 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:131:1
[INFO] [stdout]     |
[INFO] [stdout] 131 |   apply_to_primitives!(forward_assign_primitive{BigInt, _, ShrAssign, shr_assign});
[INFO] [stdout]     |   -------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:266:48
[INFO] [stdout]     |
[INFO] [stdout] 260 | / macro_rules! forward_assign_primitive {
[INFO] [stdout] 261 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 262 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 263 | |             $trait::$fn(&mut lhs.0, rhs).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 266 | |             $trait::$fn(&mut lhs.0, *rhs).into()
[INFO] [stdout]     | |                                                ^
[INFO] [stdout] 267 | |         });
[INFO] [stdout] 268 | |     };
[INFO] [stdout] 269 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:131:1
[INFO] [stdout]     |
[INFO] [stdout] 131 |   apply_to_primitives!(forward_assign_primitive{BigInt, _, ShrAssign, shr_assign});
[INFO] [stdout]     |   -------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:263:47
[INFO] [stdout]     |
[INFO] [stdout] 260 | / macro_rules! forward_assign_primitive {
[INFO] [stdout] 261 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 262 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 263 | |             $trait::$fn(&mut lhs.0, rhs).into()
[INFO] [stdout]     | |                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 268 | |     };
[INFO] [stdout] 269 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:131:1
[INFO] [stdout]     |
[INFO] [stdout] 131 |   apply_to_primitives!(forward_assign_primitive{BigInt, _, ShrAssign, shr_assign});
[INFO] [stdout]     |   -------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:266:48
[INFO] [stdout]     |
[INFO] [stdout] 260 | / macro_rules! forward_assign_primitive {
[INFO] [stdout] 261 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 262 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 263 | |             $trait::$fn(&mut lhs.0, rhs).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 266 | |             $trait::$fn(&mut lhs.0, *rhs).into()
[INFO] [stdout]     | |                                                ^
[INFO] [stdout] 267 | |         });
[INFO] [stdout] 268 | |     };
[INFO] [stdout] 269 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:131:1
[INFO] [stdout]     |
[INFO] [stdout] 131 |   apply_to_primitives!(forward_assign_primitive{BigInt, _, ShrAssign, shr_assign});
[INFO] [stdout]     |   -------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:263:47
[INFO] [stdout]     |
[INFO] [stdout] 260 | / macro_rules! forward_assign_primitive {
[INFO] [stdout] 261 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 262 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 263 | |             $trait::$fn(&mut lhs.0, rhs).into()
[INFO] [stdout]     | |                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 268 | |     };
[INFO] [stdout] 269 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:131:1
[INFO] [stdout]     |
[INFO] [stdout] 131 |   apply_to_primitives!(forward_assign_primitive{BigInt, _, ShrAssign, shr_assign});
[INFO] [stdout]     |   -------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:266:48
[INFO] [stdout]     |
[INFO] [stdout] 260 | / macro_rules! forward_assign_primitive {
[INFO] [stdout] 261 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 262 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 263 | |             $trait::$fn(&mut lhs.0, rhs).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 266 | |             $trait::$fn(&mut lhs.0, *rhs).into()
[INFO] [stdout]     | |                                                ^
[INFO] [stdout] 267 | |         });
[INFO] [stdout] 268 | |     };
[INFO] [stdout] 269 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:131:1
[INFO] [stdout]     |
[INFO] [stdout] 131 |   apply_to_primitives!(forward_assign_primitive{BigInt, _, ShrAssign, shr_assign});
[INFO] [stdout]     |   -------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:263:47
[INFO] [stdout]     |
[INFO] [stdout] 260 | / macro_rules! forward_assign_primitive {
[INFO] [stdout] 261 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 262 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 263 | |             $trait::$fn(&mut lhs.0, rhs).into()
[INFO] [stdout]     | |                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 268 | |     };
[INFO] [stdout] 269 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:131:1
[INFO] [stdout]     |
[INFO] [stdout] 131 |   apply_to_primitives!(forward_assign_primitive{BigInt, _, ShrAssign, shr_assign});
[INFO] [stdout]     |   -------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:266:48
[INFO] [stdout]     |
[INFO] [stdout] 260 | / macro_rules! forward_assign_primitive {
[INFO] [stdout] 261 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 262 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 263 | |             $trait::$fn(&mut lhs.0, rhs).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 266 | |             $trait::$fn(&mut lhs.0, *rhs).into()
[INFO] [stdout]     | |                                                ^
[INFO] [stdout] 267 | |         });
[INFO] [stdout] 268 | |     };
[INFO] [stdout] 269 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:131:1
[INFO] [stdout]     |
[INFO] [stdout] 131 |   apply_to_primitives!(forward_assign_primitive{BigInt, _, ShrAssign, shr_assign});
[INFO] [stdout]     |   -------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:263:47
[INFO] [stdout]     |
[INFO] [stdout] 260 | / macro_rules! forward_assign_primitive {
[INFO] [stdout] 261 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 262 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 263 | |             $trait::$fn(&mut lhs.0, rhs).into()
[INFO] [stdout]     | |                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 268 | |     };
[INFO] [stdout] 269 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:131:1
[INFO] [stdout]     |
[INFO] [stdout] 131 |   apply_to_primitives!(forward_assign_primitive{BigInt, _, ShrAssign, shr_assign});
[INFO] [stdout]     |   -------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:266:48
[INFO] [stdout]     |
[INFO] [stdout] 260 | / macro_rules! forward_assign_primitive {
[INFO] [stdout] 261 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 262 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 263 | |             $trait::$fn(&mut lhs.0, rhs).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 266 | |             $trait::$fn(&mut lhs.0, *rhs).into()
[INFO] [stdout]     | |                                                ^
[INFO] [stdout] 267 | |         });
[INFO] [stdout] 268 | |     };
[INFO] [stdout] 269 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:131:1
[INFO] [stdout]     |
[INFO] [stdout] 131 |   apply_to_primitives!(forward_assign_primitive{BigInt, _, ShrAssign, shr_assign});
[INFO] [stdout]     |   -------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:263:47
[INFO] [stdout]     |
[INFO] [stdout] 260 | / macro_rules! forward_assign_primitive {
[INFO] [stdout] 261 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 262 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 263 | |             $trait::$fn(&mut lhs.0, rhs).into()
[INFO] [stdout]     | |                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 268 | |     };
[INFO] [stdout] 269 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:102:1
[INFO] [stdout]     |
[INFO] [stdout] 102 |   apply_to_primitives!(forward_assign_primitive{BigUint, _, ShlAssign, shl_assign});
[INFO] [stdout]     |   --------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:266:48
[INFO] [stdout]     |
[INFO] [stdout] 260 | / macro_rules! forward_assign_primitive {
[INFO] [stdout] 261 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 262 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 263 | |             $trait::$fn(&mut lhs.0, rhs).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 266 | |             $trait::$fn(&mut lhs.0, *rhs).into()
[INFO] [stdout]     | |                                                ^
[INFO] [stdout] 267 | |         });
[INFO] [stdout] 268 | |     };
[INFO] [stdout] 269 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:102:1
[INFO] [stdout]     |
[INFO] [stdout] 102 |   apply_to_primitives!(forward_assign_primitive{BigUint, _, ShlAssign, shl_assign});
[INFO] [stdout]     |   --------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:263:47
[INFO] [stdout]     |
[INFO] [stdout] 260 | / macro_rules! forward_assign_primitive {
[INFO] [stdout] 261 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 262 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 263 | |             $trait::$fn(&mut lhs.0, rhs).into()
[INFO] [stdout]     | |                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 268 | |     };
[INFO] [stdout] 269 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:102:1
[INFO] [stdout]     |
[INFO] [stdout] 102 |   apply_to_primitives!(forward_assign_primitive{BigUint, _, ShlAssign, shl_assign});
[INFO] [stdout]     |   --------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:266:48
[INFO] [stdout]     |
[INFO] [stdout] 260 | / macro_rules! forward_assign_primitive {
[INFO] [stdout] 261 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 262 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 263 | |             $trait::$fn(&mut lhs.0, rhs).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 266 | |             $trait::$fn(&mut lhs.0, *rhs).into()
[INFO] [stdout]     | |                                                ^
[INFO] [stdout] 267 | |         });
[INFO] [stdout] 268 | |     };
[INFO] [stdout] 269 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:102:1
[INFO] [stdout]     |
[INFO] [stdout] 102 |   apply_to_primitives!(forward_assign_primitive{BigUint, _, ShlAssign, shl_assign});
[INFO] [stdout]     |   --------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:263:47
[INFO] [stdout]     |
[INFO] [stdout] 260 | / macro_rules! forward_assign_primitive {
[INFO] [stdout] 261 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 262 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 263 | |             $trait::$fn(&mut lhs.0, rhs).into()
[INFO] [stdout]     | |                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 268 | |     };
[INFO] [stdout] 269 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:102:1
[INFO] [stdout]     |
[INFO] [stdout] 102 |   apply_to_primitives!(forward_assign_primitive{BigUint, _, ShlAssign, shl_assign});
[INFO] [stdout]     |   --------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:266:48
[INFO] [stdout]     |
[INFO] [stdout] 260 | / macro_rules! forward_assign_primitive {
[INFO] [stdout] 261 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 262 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 263 | |             $trait::$fn(&mut lhs.0, rhs).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 266 | |             $trait::$fn(&mut lhs.0, *rhs).into()
[INFO] [stdout]     | |                                                ^
[INFO] [stdout] 267 | |         });
[INFO] [stdout] 268 | |     };
[INFO] [stdout] 269 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:102:1
[INFO] [stdout]     |
[INFO] [stdout] 102 |   apply_to_primitives!(forward_assign_primitive{BigUint, _, ShlAssign, shl_assign});
[INFO] [stdout]     |   --------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:263:47
[INFO] [stdout]     |
[INFO] [stdout] 260 | / macro_rules! forward_assign_primitive {
[INFO] [stdout] 261 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 262 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 263 | |             $trait::$fn(&mut lhs.0, rhs).into()
[INFO] [stdout]     | |                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 268 | |     };
[INFO] [stdout] 269 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:102:1
[INFO] [stdout]     |
[INFO] [stdout] 102 |   apply_to_primitives!(forward_assign_primitive{BigUint, _, ShlAssign, shl_assign});
[INFO] [stdout]     |   --------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:266:48
[INFO] [stdout]     |
[INFO] [stdout] 260 | / macro_rules! forward_assign_primitive {
[INFO] [stdout] 261 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 262 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 263 | |             $trait::$fn(&mut lhs.0, rhs).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 266 | |             $trait::$fn(&mut lhs.0, *rhs).into()
[INFO] [stdout]     | |                                                ^
[INFO] [stdout] 267 | |         });
[INFO] [stdout] 268 | |     };
[INFO] [stdout] 269 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:102:1
[INFO] [stdout]     |
[INFO] [stdout] 102 |   apply_to_primitives!(forward_assign_primitive{BigUint, _, ShlAssign, shl_assign});
[INFO] [stdout]     |   --------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:263:47
[INFO] [stdout]     |
[INFO] [stdout] 260 | / macro_rules! forward_assign_primitive {
[INFO] [stdout] 261 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 262 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 263 | |             $trait::$fn(&mut lhs.0, rhs).into()
[INFO] [stdout]     | |                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 268 | |     };
[INFO] [stdout] 269 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:102:1
[INFO] [stdout]     |
[INFO] [stdout] 102 |   apply_to_primitives!(forward_assign_primitive{BigUint, _, ShlAssign, shl_assign});
[INFO] [stdout]     |   --------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:266:48
[INFO] [stdout]     |
[INFO] [stdout] 260 | / macro_rules! forward_assign_primitive {
[INFO] [stdout] 261 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 262 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 263 | |             $trait::$fn(&mut lhs.0, rhs).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 266 | |             $trait::$fn(&mut lhs.0, *rhs).into()
[INFO] [stdout]     | |                                                ^
[INFO] [stdout] 267 | |         });
[INFO] [stdout] 268 | |     };
[INFO] [stdout] 269 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:102:1
[INFO] [stdout]     |
[INFO] [stdout] 102 |   apply_to_primitives!(forward_assign_primitive{BigUint, _, ShlAssign, shl_assign});
[INFO] [stdout]     |   --------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:263:47
[INFO] [stdout]     |
[INFO] [stdout] 260 | / macro_rules! forward_assign_primitive {
[INFO] [stdout] 261 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 262 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 263 | |             $trait::$fn(&mut lhs.0, rhs).into()
[INFO] [stdout]     | |                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 268 | |     };
[INFO] [stdout] 269 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:102:1
[INFO] [stdout]     |
[INFO] [stdout] 102 |   apply_to_primitives!(forward_assign_primitive{BigUint, _, ShlAssign, shl_assign});
[INFO] [stdout]     |   --------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:266:48
[INFO] [stdout]     |
[INFO] [stdout] 260 | / macro_rules! forward_assign_primitive {
[INFO] [stdout] 261 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 262 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 263 | |             $trait::$fn(&mut lhs.0, rhs).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 266 | |             $trait::$fn(&mut lhs.0, *rhs).into()
[INFO] [stdout]     | |                                                ^
[INFO] [stdout] 267 | |         });
[INFO] [stdout] 268 | |     };
[INFO] [stdout] 269 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:102:1
[INFO] [stdout]     |
[INFO] [stdout] 102 |   apply_to_primitives!(forward_assign_primitive{BigUint, _, ShlAssign, shl_assign});
[INFO] [stdout]     |   --------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:263:47
[INFO] [stdout]     |
[INFO] [stdout] 260 | / macro_rules! forward_assign_primitive {
[INFO] [stdout] 261 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 262 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 263 | |             $trait::$fn(&mut lhs.0, rhs).into()
[INFO] [stdout]     | |                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 268 | |     };
[INFO] [stdout] 269 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:102:1
[INFO] [stdout]     |
[INFO] [stdout] 102 |   apply_to_primitives!(forward_assign_primitive{BigUint, _, ShlAssign, shl_assign});
[INFO] [stdout]     |   --------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:266:48
[INFO] [stdout]     |
[INFO] [stdout] 260 | / macro_rules! forward_assign_primitive {
[INFO] [stdout] 261 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 262 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 263 | |             $trait::$fn(&mut lhs.0, rhs).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 266 | |             $trait::$fn(&mut lhs.0, *rhs).into()
[INFO] [stdout]     | |                                                ^
[INFO] [stdout] 267 | |         });
[INFO] [stdout] 268 | |     };
[INFO] [stdout] 269 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:102:1
[INFO] [stdout]     |
[INFO] [stdout] 102 |   apply_to_primitives!(forward_assign_primitive{BigUint, _, ShlAssign, shl_assign});
[INFO] [stdout]     |   --------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:263:47
[INFO] [stdout]     |
[INFO] [stdout] 260 | / macro_rules! forward_assign_primitive {
[INFO] [stdout] 261 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 262 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 263 | |             $trait::$fn(&mut lhs.0, rhs).into()
[INFO] [stdout]     | |                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 268 | |     };
[INFO] [stdout] 269 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:102:1
[INFO] [stdout]     |
[INFO] [stdout] 102 |   apply_to_primitives!(forward_assign_primitive{BigUint, _, ShlAssign, shl_assign});
[INFO] [stdout]     |   --------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:266:48
[INFO] [stdout]     |
[INFO] [stdout] 260 | / macro_rules! forward_assign_primitive {
[INFO] [stdout] 261 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 262 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 263 | |             $trait::$fn(&mut lhs.0, rhs).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 266 | |             $trait::$fn(&mut lhs.0, *rhs).into()
[INFO] [stdout]     | |                                                ^
[INFO] [stdout] 267 | |         });
[INFO] [stdout] 268 | |     };
[INFO] [stdout] 269 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:102:1
[INFO] [stdout]     |
[INFO] [stdout] 102 |   apply_to_primitives!(forward_assign_primitive{BigUint, _, ShlAssign, shl_assign});
[INFO] [stdout]     |   --------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:263:47
[INFO] [stdout]     |
[INFO] [stdout] 260 | / macro_rules! forward_assign_primitive {
[INFO] [stdout] 261 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 262 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 263 | |             $trait::$fn(&mut lhs.0, rhs).into()
[INFO] [stdout]     | |                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 268 | |     };
[INFO] [stdout] 269 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:102:1
[INFO] [stdout]     |
[INFO] [stdout] 102 |   apply_to_primitives!(forward_assign_primitive{BigUint, _, ShlAssign, shl_assign});
[INFO] [stdout]     |   --------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:266:48
[INFO] [stdout]     |
[INFO] [stdout] 260 | / macro_rules! forward_assign_primitive {
[INFO] [stdout] 261 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 262 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 263 | |             $trait::$fn(&mut lhs.0, rhs).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 266 | |             $trait::$fn(&mut lhs.0, *rhs).into()
[INFO] [stdout]     | |                                                ^
[INFO] [stdout] 267 | |         });
[INFO] [stdout] 268 | |     };
[INFO] [stdout] 269 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:102:1
[INFO] [stdout]     |
[INFO] [stdout] 102 |   apply_to_primitives!(forward_assign_primitive{BigUint, _, ShlAssign, shl_assign});
[INFO] [stdout]     |   --------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:263:47
[INFO] [stdout]     |
[INFO] [stdout] 260 | / macro_rules! forward_assign_primitive {
[INFO] [stdout] 261 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 262 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 263 | |             $trait::$fn(&mut lhs.0, rhs).into()
[INFO] [stdout]     | |                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 268 | |     };
[INFO] [stdout] 269 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:102:1
[INFO] [stdout]     |
[INFO] [stdout] 102 |   apply_to_primitives!(forward_assign_primitive{BigUint, _, ShlAssign, shl_assign});
[INFO] [stdout]     |   --------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:266:48
[INFO] [stdout]     |
[INFO] [stdout] 260 | / macro_rules! forward_assign_primitive {
[INFO] [stdout] 261 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 262 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 263 | |             $trait::$fn(&mut lhs.0, rhs).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 266 | |             $trait::$fn(&mut lhs.0, *rhs).into()
[INFO] [stdout]     | |                                                ^
[INFO] [stdout] 267 | |         });
[INFO] [stdout] 268 | |     };
[INFO] [stdout] 269 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:102:1
[INFO] [stdout]     |
[INFO] [stdout] 102 |   apply_to_primitives!(forward_assign_primitive{BigUint, _, ShlAssign, shl_assign});
[INFO] [stdout]     |   --------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:263:47
[INFO] [stdout]     |
[INFO] [stdout] 260 | / macro_rules! forward_assign_primitive {
[INFO] [stdout] 261 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 262 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 263 | |             $trait::$fn(&mut lhs.0, rhs).into()
[INFO] [stdout]     | |                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 268 | |     };
[INFO] [stdout] 269 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:102:1
[INFO] [stdout]     |
[INFO] [stdout] 102 |   apply_to_primitives!(forward_assign_primitive{BigUint, _, ShlAssign, shl_assign});
[INFO] [stdout]     |   --------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:266:48
[INFO] [stdout]     |
[INFO] [stdout] 260 | / macro_rules! forward_assign_primitive {
[INFO] [stdout] 261 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 262 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 263 | |             $trait::$fn(&mut lhs.0, rhs).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 266 | |             $trait::$fn(&mut lhs.0, *rhs).into()
[INFO] [stdout]     | |                                                ^
[INFO] [stdout] 267 | |         });
[INFO] [stdout] 268 | |     };
[INFO] [stdout] 269 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:102:1
[INFO] [stdout]     |
[INFO] [stdout] 102 |   apply_to_primitives!(forward_assign_primitive{BigUint, _, ShlAssign, shl_assign});
[INFO] [stdout]     |   --------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:263:47
[INFO] [stdout]     |
[INFO] [stdout] 260 | / macro_rules! forward_assign_primitive {
[INFO] [stdout] 261 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 262 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 263 | |             $trait::$fn(&mut lhs.0, rhs).into()
[INFO] [stdout]     | |                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 268 | |     };
[INFO] [stdout] 269 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:102:1
[INFO] [stdout]     |
[INFO] [stdout] 102 |   apply_to_primitives!(forward_assign_primitive{BigUint, _, ShlAssign, shl_assign});
[INFO] [stdout]     |   --------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:266:48
[INFO] [stdout]     |
[INFO] [stdout] 260 | / macro_rules! forward_assign_primitive {
[INFO] [stdout] 261 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 262 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 263 | |             $trait::$fn(&mut lhs.0, rhs).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 266 | |             $trait::$fn(&mut lhs.0, *rhs).into()
[INFO] [stdout]     | |                                                ^
[INFO] [stdout] 267 | |         });
[INFO] [stdout] 268 | |     };
[INFO] [stdout] 269 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:102:1
[INFO] [stdout]     |
[INFO] [stdout] 102 |   apply_to_primitives!(forward_assign_primitive{BigUint, _, ShlAssign, shl_assign});
[INFO] [stdout]     |   --------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:263:47
[INFO] [stdout]     |
[INFO] [stdout] 260 | / macro_rules! forward_assign_primitive {
[INFO] [stdout] 261 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 262 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 263 | |             $trait::$fn(&mut lhs.0, rhs).into()
[INFO] [stdout]     | |                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 268 | |     };
[INFO] [stdout] 269 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:103:1
[INFO] [stdout]     |
[INFO] [stdout] 103 |   apply_to_primitives!(forward_assign_primitive{BigUint, _, ShrAssign, shr_assign});
[INFO] [stdout]     |   --------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:266:48
[INFO] [stdout]     |
[INFO] [stdout] 260 | / macro_rules! forward_assign_primitive {
[INFO] [stdout] 261 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 262 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 263 | |             $trait::$fn(&mut lhs.0, rhs).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 266 | |             $trait::$fn(&mut lhs.0, *rhs).into()
[INFO] [stdout]     | |                                                ^
[INFO] [stdout] 267 | |         });
[INFO] [stdout] 268 | |     };
[INFO] [stdout] 269 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:103:1
[INFO] [stdout]     |
[INFO] [stdout] 103 |   apply_to_primitives!(forward_assign_primitive{BigUint, _, ShrAssign, shr_assign});
[INFO] [stdout]     |   --------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:263:47
[INFO] [stdout]     |
[INFO] [stdout] 260 | / macro_rules! forward_assign_primitive {
[INFO] [stdout] 261 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 262 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 263 | |             $trait::$fn(&mut lhs.0, rhs).into()
[INFO] [stdout]     | |                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 268 | |     };
[INFO] [stdout] 269 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:103:1
[INFO] [stdout]     |
[INFO] [stdout] 103 |   apply_to_primitives!(forward_assign_primitive{BigUint, _, ShrAssign, shr_assign});
[INFO] [stdout]     |   --------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:266:48
[INFO] [stdout]     |
[INFO] [stdout] 260 | / macro_rules! forward_assign_primitive {
[INFO] [stdout] 261 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 262 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 263 | |             $trait::$fn(&mut lhs.0, rhs).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 266 | |             $trait::$fn(&mut lhs.0, *rhs).into()
[INFO] [stdout]     | |                                                ^
[INFO] [stdout] 267 | |         });
[INFO] [stdout] 268 | |     };
[INFO] [stdout] 269 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:103:1
[INFO] [stdout]     |
[INFO] [stdout] 103 |   apply_to_primitives!(forward_assign_primitive{BigUint, _, ShrAssign, shr_assign});
[INFO] [stdout]     |   --------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:263:47
[INFO] [stdout]     |
[INFO] [stdout] 260 | / macro_rules! forward_assign_primitive {
[INFO] [stdout] 261 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 262 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 263 | |             $trait::$fn(&mut lhs.0, rhs).into()
[INFO] [stdout]     | |                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 268 | |     };
[INFO] [stdout] 269 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:103:1
[INFO] [stdout]     |
[INFO] [stdout] 103 |   apply_to_primitives!(forward_assign_primitive{BigUint, _, ShrAssign, shr_assign});
[INFO] [stdout]     |   --------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:266:48
[INFO] [stdout]     |
[INFO] [stdout] 260 | / macro_rules! forward_assign_primitive {
[INFO] [stdout] 261 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 262 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 263 | |             $trait::$fn(&mut lhs.0, rhs).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 266 | |             $trait::$fn(&mut lhs.0, *rhs).into()
[INFO] [stdout]     | |                                                ^
[INFO] [stdout] 267 | |         });
[INFO] [stdout] 268 | |     };
[INFO] [stdout] 269 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:103:1
[INFO] [stdout]     |
[INFO] [stdout] 103 |   apply_to_primitives!(forward_assign_primitive{BigUint, _, ShrAssign, shr_assign});
[INFO] [stdout]     |   --------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:263:47
[INFO] [stdout]     |
[INFO] [stdout] 260 | / macro_rules! forward_assign_primitive {
[INFO] [stdout] 261 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 262 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 263 | |             $trait::$fn(&mut lhs.0, rhs).into()
[INFO] [stdout]     | |                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 268 | |     };
[INFO] [stdout] 269 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:103:1
[INFO] [stdout]     |
[INFO] [stdout] 103 |   apply_to_primitives!(forward_assign_primitive{BigUint, _, ShrAssign, shr_assign});
[INFO] [stdout]     |   --------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:266:48
[INFO] [stdout]     |
[INFO] [stdout] 260 | / macro_rules! forward_assign_primitive {
[INFO] [stdout] 261 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 262 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 263 | |             $trait::$fn(&mut lhs.0, rhs).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 266 | |             $trait::$fn(&mut lhs.0, *rhs).into()
[INFO] [stdout]     | |                                                ^
[INFO] [stdout] 267 | |         });
[INFO] [stdout] 268 | |     };
[INFO] [stdout] 269 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:103:1
[INFO] [stdout]     |
[INFO] [stdout] 103 |   apply_to_primitives!(forward_assign_primitive{BigUint, _, ShrAssign, shr_assign});
[INFO] [stdout]     |   --------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:263:47
[INFO] [stdout]     |
[INFO] [stdout] 260 | / macro_rules! forward_assign_primitive {
[INFO] [stdout] 261 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 262 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 263 | |             $trait::$fn(&mut lhs.0, rhs).into()
[INFO] [stdout]     | |                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 268 | |     };
[INFO] [stdout] 269 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:103:1
[INFO] [stdout]     |
[INFO] [stdout] 103 |   apply_to_primitives!(forward_assign_primitive{BigUint, _, ShrAssign, shr_assign});
[INFO] [stdout]     |   --------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:266:48
[INFO] [stdout]     |
[INFO] [stdout] 260 | / macro_rules! forward_assign_primitive {
[INFO] [stdout] 261 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 262 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 263 | |             $trait::$fn(&mut lhs.0, rhs).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 266 | |             $trait::$fn(&mut lhs.0, *rhs).into()
[INFO] [stdout]     | |                                                ^
[INFO] [stdout] 267 | |         });
[INFO] [stdout] 268 | |     };
[INFO] [stdout] 269 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:103:1
[INFO] [stdout]     |
[INFO] [stdout] 103 |   apply_to_primitives!(forward_assign_primitive{BigUint, _, ShrAssign, shr_assign});
[INFO] [stdout]     |   --------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:263:47
[INFO] [stdout]     |
[INFO] [stdout] 260 | / macro_rules! forward_assign_primitive {
[INFO] [stdout] 261 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 262 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 263 | |             $trait::$fn(&mut lhs.0, rhs).into()
[INFO] [stdout]     | |                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 268 | |     };
[INFO] [stdout] 269 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:103:1
[INFO] [stdout]     |
[INFO] [stdout] 103 |   apply_to_primitives!(forward_assign_primitive{BigUint, _, ShrAssign, shr_assign});
[INFO] [stdout]     |   --------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:266:48
[INFO] [stdout]     |
[INFO] [stdout] 260 | / macro_rules! forward_assign_primitive {
[INFO] [stdout] 261 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 262 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 263 | |             $trait::$fn(&mut lhs.0, rhs).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 266 | |             $trait::$fn(&mut lhs.0, *rhs).into()
[INFO] [stdout]     | |                                                ^
[INFO] [stdout] 267 | |         });
[INFO] [stdout] 268 | |     };
[INFO] [stdout] 269 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:103:1
[INFO] [stdout]     |
[INFO] [stdout] 103 |   apply_to_primitives!(forward_assign_primitive{BigUint, _, ShrAssign, shr_assign});
[INFO] [stdout]     |   --------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:263:47
[INFO] [stdout]     |
[INFO] [stdout] 260 | / macro_rules! forward_assign_primitive {
[INFO] [stdout] 261 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 262 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 263 | |             $trait::$fn(&mut lhs.0, rhs).into()
[INFO] [stdout]     | |                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 268 | |     };
[INFO] [stdout] 269 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:103:1
[INFO] [stdout]     |
[INFO] [stdout] 103 |   apply_to_primitives!(forward_assign_primitive{BigUint, _, ShrAssign, shr_assign});
[INFO] [stdout]     |   --------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:266:48
[INFO] [stdout]     |
[INFO] [stdout] 260 | / macro_rules! forward_assign_primitive {
[INFO] [stdout] 261 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 262 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 263 | |             $trait::$fn(&mut lhs.0, rhs).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 266 | |             $trait::$fn(&mut lhs.0, *rhs).into()
[INFO] [stdout]     | |                                                ^
[INFO] [stdout] 267 | |         });
[INFO] [stdout] 268 | |     };
[INFO] [stdout] 269 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:103:1
[INFO] [stdout]     |
[INFO] [stdout] 103 |   apply_to_primitives!(forward_assign_primitive{BigUint, _, ShrAssign, shr_assign});
[INFO] [stdout]     |   --------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:263:47
[INFO] [stdout]     |
[INFO] [stdout] 260 | / macro_rules! forward_assign_primitive {
[INFO] [stdout] 261 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 262 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 263 | |             $trait::$fn(&mut lhs.0, rhs).into()
[INFO] [stdout]     | |                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 268 | |     };
[INFO] [stdout] 269 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:103:1
[INFO] [stdout]     |
[INFO] [stdout] 103 |   apply_to_primitives!(forward_assign_primitive{BigUint, _, ShrAssign, shr_assign});
[INFO] [stdout]     |   --------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:266:48
[INFO] [stdout]     |
[INFO] [stdout] 260 | / macro_rules! forward_assign_primitive {
[INFO] [stdout] 261 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 262 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 263 | |             $trait::$fn(&mut lhs.0, rhs).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 266 | |             $trait::$fn(&mut lhs.0, *rhs).into()
[INFO] [stdout]     | |                                                ^
[INFO] [stdout] 267 | |         });
[INFO] [stdout] 268 | |     };
[INFO] [stdout] 269 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:103:1
[INFO] [stdout]     |
[INFO] [stdout] 103 |   apply_to_primitives!(forward_assign_primitive{BigUint, _, ShrAssign, shr_assign});
[INFO] [stdout]     |   --------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:263:47
[INFO] [stdout]     |
[INFO] [stdout] 260 | / macro_rules! forward_assign_primitive {
[INFO] [stdout] 261 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 262 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 263 | |             $trait::$fn(&mut lhs.0, rhs).into()
[INFO] [stdout]     | |                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 268 | |     };
[INFO] [stdout] 269 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:103:1
[INFO] [stdout]     |
[INFO] [stdout] 103 |   apply_to_primitives!(forward_assign_primitive{BigUint, _, ShrAssign, shr_assign});
[INFO] [stdout]     |   --------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:266:48
[INFO] [stdout]     |
[INFO] [stdout] 260 | / macro_rules! forward_assign_primitive {
[INFO] [stdout] 261 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 262 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 263 | |             $trait::$fn(&mut lhs.0, rhs).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 266 | |             $trait::$fn(&mut lhs.0, *rhs).into()
[INFO] [stdout]     | |                                                ^
[INFO] [stdout] 267 | |         });
[INFO] [stdout] 268 | |     };
[INFO] [stdout] 269 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:103:1
[INFO] [stdout]     |
[INFO] [stdout] 103 |   apply_to_primitives!(forward_assign_primitive{BigUint, _, ShrAssign, shr_assign});
[INFO] [stdout]     |   --------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:263:47
[INFO] [stdout]     |
[INFO] [stdout] 260 | / macro_rules! forward_assign_primitive {
[INFO] [stdout] 261 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 262 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 263 | |             $trait::$fn(&mut lhs.0, rhs).into()
[INFO] [stdout]     | |                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 268 | |     };
[INFO] [stdout] 269 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:103:1
[INFO] [stdout]     |
[INFO] [stdout] 103 |   apply_to_primitives!(forward_assign_primitive{BigUint, _, ShrAssign, shr_assign});
[INFO] [stdout]     |   --------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:266:48
[INFO] [stdout]     |
[INFO] [stdout] 260 | / macro_rules! forward_assign_primitive {
[INFO] [stdout] 261 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 262 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 263 | |             $trait::$fn(&mut lhs.0, rhs).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 266 | |             $trait::$fn(&mut lhs.0, *rhs).into()
[INFO] [stdout]     | |                                                ^
[INFO] [stdout] 267 | |         });
[INFO] [stdout] 268 | |     };
[INFO] [stdout] 269 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:103:1
[INFO] [stdout]     |
[INFO] [stdout] 103 |   apply_to_primitives!(forward_assign_primitive{BigUint, _, ShrAssign, shr_assign});
[INFO] [stdout]     |   --------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:263:47
[INFO] [stdout]     |
[INFO] [stdout] 260 | / macro_rules! forward_assign_primitive {
[INFO] [stdout] 261 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 262 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 263 | |             $trait::$fn(&mut lhs.0, rhs).into()
[INFO] [stdout]     | |                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 268 | |     };
[INFO] [stdout] 269 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:103:1
[INFO] [stdout]     |
[INFO] [stdout] 103 |   apply_to_primitives!(forward_assign_primitive{BigUint, _, ShrAssign, shr_assign});
[INFO] [stdout]     |   --------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:266:48
[INFO] [stdout]     |
[INFO] [stdout] 260 | / macro_rules! forward_assign_primitive {
[INFO] [stdout] 261 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 262 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 263 | |             $trait::$fn(&mut lhs.0, rhs).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 266 | |             $trait::$fn(&mut lhs.0, *rhs).into()
[INFO] [stdout]     | |                                                ^
[INFO] [stdout] 267 | |         });
[INFO] [stdout] 268 | |     };
[INFO] [stdout] 269 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:103:1
[INFO] [stdout]     |
[INFO] [stdout] 103 |   apply_to_primitives!(forward_assign_primitive{BigUint, _, ShrAssign, shr_assign});
[INFO] [stdout]     |   --------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:263:47
[INFO] [stdout]     |
[INFO] [stdout] 260 | / macro_rules! forward_assign_primitive {
[INFO] [stdout] 261 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 262 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 263 | |             $trait::$fn(&mut lhs.0, rhs).into()
[INFO] [stdout]     | |                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 268 | |     };
[INFO] [stdout] 269 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:103:1
[INFO] [stdout]     |
[INFO] [stdout] 103 |   apply_to_primitives!(forward_assign_primitive{BigUint, _, ShrAssign, shr_assign});
[INFO] [stdout]     |   --------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:266:48
[INFO] [stdout]     |
[INFO] [stdout] 260 | / macro_rules! forward_assign_primitive {
[INFO] [stdout] 261 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 262 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 263 | |             $trait::$fn(&mut lhs.0, rhs).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 266 | |             $trait::$fn(&mut lhs.0, *rhs).into()
[INFO] [stdout]     | |                                                ^
[INFO] [stdout] 267 | |         });
[INFO] [stdout] 268 | |     };
[INFO] [stdout] 269 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:103:1
[INFO] [stdout]     |
[INFO] [stdout] 103 |   apply_to_primitives!(forward_assign_primitive{BigUint, _, ShrAssign, shr_assign});
[INFO] [stdout]     |   --------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `malachite-bigint` (lib) due to 308 previous errors
[INFO] [stderr] warning: build failed, waiting for other jobs to finish...
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:248:49
[INFO] [stdout]     |
[INFO] [stdout] 241 | macro_rules! forward_assign_self {
[INFO] [stdout] ...
[INFO] [stdout] 248 |             |lhs: &mut $struct, rhs: $struct| { $trait::$fn(&mut lhs.0, rhs.0).into() }
[INFO] [stdout]     |                                                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:98:1
[INFO] [stdout]     |
[INFO] [stdout]  98 | forward_assign_self!(BigInt, AddAssign, add_assign);
[INFO] [stdout]     | --------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::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: `()`
[INFO] [stdout]    --> src/macros.rs:255:50
[INFO] [stdout]     |
[INFO] [stdout] 241 | macro_rules! forward_assign_self {
[INFO] [stdout] ...
[INFO] [stdout] 255 |             |lhs: &mut $struct, rhs: &$struct| { $trait::$fn(&mut lhs.0, &rhs.0).into() }
[INFO] [stdout]     |                                                  ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:98:1
[INFO] [stdout]     |
[INFO] [stdout]  98 | forward_assign_self!(BigInt, AddAssign, add_assign);
[INFO] [stdout]     | --------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:248:85
[INFO] [stdout]     |
[INFO] [stdout] 241 | macro_rules! forward_assign_self {
[INFO] [stdout] ...
[INFO] [stdout] 248 |             |lhs: &mut $struct, rhs: $struct| { $trait::$fn(&mut lhs.0, rhs.0).into() }
[INFO] [stdout]     |                                                                                     ^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:99:1
[INFO] [stdout]     |
[INFO] [stdout]  99 | forward_assign_self!(BigInt, SubAssign, sub_assign);
[INFO] [stdout]     | --------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:255:87
[INFO] [stdout]     |
[INFO] [stdout] 241 | macro_rules! forward_assign_self {
[INFO] [stdout] ...
[INFO] [stdout] 255 |             |lhs: &mut $struct, rhs: &$struct| { $trait::$fn(&mut lhs.0, &rhs.0).into() }
[INFO] [stdout]     |                                                                                       ^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:99:1
[INFO] [stdout]     |
[INFO] [stdout]  99 | forward_assign_self!(BigInt, SubAssign, sub_assign);
[INFO] [stdout]     | --------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:248:85
[INFO] [stdout]     |
[INFO] [stdout] 241 | macro_rules! forward_assign_self {
[INFO] [stdout] ...
[INFO] [stdout] 248 |             |lhs: &mut $struct, rhs: $struct| { $trait::$fn(&mut lhs.0, rhs.0).into() }
[INFO] [stdout]     |                                                                                     ^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:100:1
[INFO] [stdout]     |
[INFO] [stdout] 100 | forward_assign_self!(BigInt, MulAssign, mul_assign);
[INFO] [stdout]     | --------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:255:87
[INFO] [stdout]     |
[INFO] [stdout] 241 | macro_rules! forward_assign_self {
[INFO] [stdout] ...
[INFO] [stdout] 255 |             |lhs: &mut $struct, rhs: &$struct| { $trait::$fn(&mut lhs.0, &rhs.0).into() }
[INFO] [stdout]     |                                                                                       ^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:100:1
[INFO] [stdout]     |
[INFO] [stdout] 100 | forward_assign_self!(BigInt, MulAssign, mul_assign);
[INFO] [stdout]     | --------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:248:85
[INFO] [stdout]     |
[INFO] [stdout] 241 | macro_rules! forward_assign_self {
[INFO] [stdout] ...
[INFO] [stdout] 248 |             |lhs: &mut $struct, rhs: $struct| { $trait::$fn(&mut lhs.0, rhs.0).into() }
[INFO] [stdout]     |                                                                                     ^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:101:1
[INFO] [stdout]     |
[INFO] [stdout] 101 | forward_assign_self!(BigInt, DivAssign, div_assign);
[INFO] [stdout]     | --------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:255:87
[INFO] [stdout]     |
[INFO] [stdout] 241 | macro_rules! forward_assign_self {
[INFO] [stdout] ...
[INFO] [stdout] 255 |             |lhs: &mut $struct, rhs: &$struct| { $trait::$fn(&mut lhs.0, &rhs.0).into() }
[INFO] [stdout]     |                                                                                       ^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:101:1
[INFO] [stdout]     |
[INFO] [stdout] 101 | forward_assign_self!(BigInt, DivAssign, div_assign);
[INFO] [stdout]     | --------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:248:85
[INFO] [stdout]     |
[INFO] [stdout] 241 | macro_rules! forward_assign_self {
[INFO] [stdout] ...
[INFO] [stdout] 248 |             |lhs: &mut $struct, rhs: $struct| { $trait::$fn(&mut lhs.0, rhs.0).into() }
[INFO] [stdout]     |                                                                                     ^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:102:1
[INFO] [stdout]     |
[INFO] [stdout] 102 | forward_assign_self!(BigInt, RemAssign, rem_assign);
[INFO] [stdout]     | --------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:255:87
[INFO] [stdout]     |
[INFO] [stdout] 241 | macro_rules! forward_assign_self {
[INFO] [stdout] ...
[INFO] [stdout] 255 |             |lhs: &mut $struct, rhs: &$struct| { $trait::$fn(&mut lhs.0, &rhs.0).into() }
[INFO] [stdout]     |                                                                                       ^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:102:1
[INFO] [stdout]     |
[INFO] [stdout] 102 | forward_assign_self!(BigInt, RemAssign, rem_assign);
[INFO] [stdout]     | --------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:248:85
[INFO] [stdout]     |
[INFO] [stdout] 241 | macro_rules! forward_assign_self {
[INFO] [stdout] ...
[INFO] [stdout] 248 |             |lhs: &mut $struct, rhs: $struct| { $trait::$fn(&mut lhs.0, rhs.0).into() }
[INFO] [stdout]     |                                                                                     ^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:103:1
[INFO] [stdout]     |
[INFO] [stdout] 103 | forward_assign_self!(BigInt, BitAndAssign, bitand_assign);
[INFO] [stdout]     | --------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:255:87
[INFO] [stdout]     |
[INFO] [stdout] 241 | macro_rules! forward_assign_self {
[INFO] [stdout] ...
[INFO] [stdout] 255 |             |lhs: &mut $struct, rhs: &$struct| { $trait::$fn(&mut lhs.0, &rhs.0).into() }
[INFO] [stdout]     |                                                                                       ^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:103:1
[INFO] [stdout]     |
[INFO] [stdout] 103 | forward_assign_self!(BigInt, BitAndAssign, bitand_assign);
[INFO] [stdout]     | --------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:248:85
[INFO] [stdout]     |
[INFO] [stdout] 241 | macro_rules! forward_assign_self {
[INFO] [stdout] ...
[INFO] [stdout] 248 |             |lhs: &mut $struct, rhs: $struct| { $trait::$fn(&mut lhs.0, rhs.0).into() }
[INFO] [stdout]     |                                                                                     ^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:104:1
[INFO] [stdout]     |
[INFO] [stdout] 104 | forward_assign_self!(BigInt, BitOrAssign, bitor_assign);
[INFO] [stdout]     | ------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:255:87
[INFO] [stdout]     |
[INFO] [stdout] 241 | macro_rules! forward_assign_self {
[INFO] [stdout] ...
[INFO] [stdout] 255 |             |lhs: &mut $struct, rhs: &$struct| { $trait::$fn(&mut lhs.0, &rhs.0).into() }
[INFO] [stdout]     |                                                                                       ^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:104:1
[INFO] [stdout]     |
[INFO] [stdout] 104 | forward_assign_self!(BigInt, BitOrAssign, bitor_assign);
[INFO] [stdout]     | ------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:248:85
[INFO] [stdout]     |
[INFO] [stdout] 241 | macro_rules! forward_assign_self {
[INFO] [stdout] ...
[INFO] [stdout] 248 |             |lhs: &mut $struct, rhs: $struct| { $trait::$fn(&mut lhs.0, rhs.0).into() }
[INFO] [stdout]     |                                                                                     ^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:105:1
[INFO] [stdout]     |
[INFO] [stdout] 105 | forward_assign_self!(BigInt, BitXorAssign, bitxor_assign);
[INFO] [stdout]     | --------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:255:87
[INFO] [stdout]     |
[INFO] [stdout] 241 | macro_rules! forward_assign_self {
[INFO] [stdout] ...
[INFO] [stdout] 255 |             |lhs: &mut $struct, rhs: &$struct| { $trait::$fn(&mut lhs.0, &rhs.0).into() }
[INFO] [stdout]     |                                                                                       ^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:105:1
[INFO] [stdout]     |
[INFO] [stdout] 105 | forward_assign_self!(BigInt, BitXorAssign, bitxor_assign);
[INFO] [stdout]     | --------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:248:85
[INFO] [stdout]     |
[INFO] [stdout] 241 | macro_rules! forward_assign_self {
[INFO] [stdout] ...
[INFO] [stdout] 248 |             |lhs: &mut $struct, rhs: $struct| { $trait::$fn(&mut lhs.0, rhs.0).into() }
[INFO] [stdout]     |                                                                                     ^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:70:1
[INFO] [stdout]     |
[INFO] [stdout]  70 | forward_assign_self!(BigUint, AddAssign, add_assign);
[INFO] [stdout]     | ---------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:255:87
[INFO] [stdout]     |
[INFO] [stdout] 241 | macro_rules! forward_assign_self {
[INFO] [stdout] ...
[INFO] [stdout] 255 |             |lhs: &mut $struct, rhs: &$struct| { $trait::$fn(&mut lhs.0, &rhs.0).into() }
[INFO] [stdout]     |                                                                                       ^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:70:1
[INFO] [stdout]     |
[INFO] [stdout]  70 | forward_assign_self!(BigUint, AddAssign, add_assign);
[INFO] [stdout]     | ---------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:248:85
[INFO] [stdout]     |
[INFO] [stdout] 241 | macro_rules! forward_assign_self {
[INFO] [stdout] ...
[INFO] [stdout] 248 |             |lhs: &mut $struct, rhs: $struct| { $trait::$fn(&mut lhs.0, rhs.0).into() }
[INFO] [stdout]     |                                                                                     ^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:71:1
[INFO] [stdout]     |
[INFO] [stdout]  71 | forward_assign_self!(BigUint, SubAssign, sub_assign);
[INFO] [stdout]     | ---------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:255:87
[INFO] [stdout]     |
[INFO] [stdout] 241 | macro_rules! forward_assign_self {
[INFO] [stdout] ...
[INFO] [stdout] 255 |             |lhs: &mut $struct, rhs: &$struct| { $trait::$fn(&mut lhs.0, &rhs.0).into() }
[INFO] [stdout]     |                                                                                       ^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:71:1
[INFO] [stdout]     |
[INFO] [stdout]  71 | forward_assign_self!(BigUint, SubAssign, sub_assign);
[INFO] [stdout]     | ---------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:248:85
[INFO] [stdout]     |
[INFO] [stdout] 241 | macro_rules! forward_assign_self {
[INFO] [stdout] ...
[INFO] [stdout] 248 |             |lhs: &mut $struct, rhs: $struct| { $trait::$fn(&mut lhs.0, rhs.0).into() }
[INFO] [stdout]     |                                                                                     ^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:72:1
[INFO] [stdout]     |
[INFO] [stdout]  72 | forward_assign_self!(BigUint, MulAssign, mul_assign);
[INFO] [stdout]     | ---------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:255:87
[INFO] [stdout]     |
[INFO] [stdout] 241 | macro_rules! forward_assign_self {
[INFO] [stdout] ...
[INFO] [stdout] 255 |             |lhs: &mut $struct, rhs: &$struct| { $trait::$fn(&mut lhs.0, &rhs.0).into() }
[INFO] [stdout]     |                                                                                       ^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:72:1
[INFO] [stdout]     |
[INFO] [stdout]  72 | forward_assign_self!(BigUint, MulAssign, mul_assign);
[INFO] [stdout]     | ---------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:248:85
[INFO] [stdout]     |
[INFO] [stdout] 241 | macro_rules! forward_assign_self {
[INFO] [stdout] ...
[INFO] [stdout] 248 |             |lhs: &mut $struct, rhs: $struct| { $trait::$fn(&mut lhs.0, rhs.0).into() }
[INFO] [stdout]     |                                                                                     ^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:73:1
[INFO] [stdout]     |
[INFO] [stdout]  73 | forward_assign_self!(BigUint, DivAssign, div_assign);
[INFO] [stdout]     | ---------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:255:87
[INFO] [stdout]     |
[INFO] [stdout] 241 | macro_rules! forward_assign_self {
[INFO] [stdout] ...
[INFO] [stdout] 255 |             |lhs: &mut $struct, rhs: &$struct| { $trait::$fn(&mut lhs.0, &rhs.0).into() }
[INFO] [stdout]     |                                                                                       ^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:73:1
[INFO] [stdout]     |
[INFO] [stdout]  73 | forward_assign_self!(BigUint, DivAssign, div_assign);
[INFO] [stdout]     | ---------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:248:85
[INFO] [stdout]     |
[INFO] [stdout] 241 | macro_rules! forward_assign_self {
[INFO] [stdout] ...
[INFO] [stdout] 248 |             |lhs: &mut $struct, rhs: $struct| { $trait::$fn(&mut lhs.0, rhs.0).into() }
[INFO] [stdout]     |                                                                                     ^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:74:1
[INFO] [stdout]     |
[INFO] [stdout]  74 | forward_assign_self!(BigUint, RemAssign, rem_assign);
[INFO] [stdout]     | ---------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:255:87
[INFO] [stdout]     |
[INFO] [stdout] 241 | macro_rules! forward_assign_self {
[INFO] [stdout] ...
[INFO] [stdout] 255 |             |lhs: &mut $struct, rhs: &$struct| { $trait::$fn(&mut lhs.0, &rhs.0).into() }
[INFO] [stdout]     |                                                                                       ^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:74:1
[INFO] [stdout]     |
[INFO] [stdout]  74 | forward_assign_self!(BigUint, RemAssign, rem_assign);
[INFO] [stdout]     | ---------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:248:85
[INFO] [stdout]     |
[INFO] [stdout] 241 | macro_rules! forward_assign_self {
[INFO] [stdout] ...
[INFO] [stdout] 248 |             |lhs: &mut $struct, rhs: $struct| { $trait::$fn(&mut lhs.0, rhs.0).into() }
[INFO] [stdout]     |                                                                                     ^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:75:1
[INFO] [stdout]     |
[INFO] [stdout]  75 | forward_assign_self!(BigUint, BitAndAssign, bitand_assign);
[INFO] [stdout]     | ---------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:255:87
[INFO] [stdout]     |
[INFO] [stdout] 241 | macro_rules! forward_assign_self {
[INFO] [stdout] ...
[INFO] [stdout] 255 |             |lhs: &mut $struct, rhs: &$struct| { $trait::$fn(&mut lhs.0, &rhs.0).into() }
[INFO] [stdout]     |                                                                                       ^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:75:1
[INFO] [stdout]     |
[INFO] [stdout]  75 | forward_assign_self!(BigUint, BitAndAssign, bitand_assign);
[INFO] [stdout]     | ---------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:248:85
[INFO] [stdout]     |
[INFO] [stdout] 241 | macro_rules! forward_assign_self {
[INFO] [stdout] ...
[INFO] [stdout] 248 |             |lhs: &mut $struct, rhs: $struct| { $trait::$fn(&mut lhs.0, rhs.0).into() }
[INFO] [stdout]     |                                                                                     ^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:76:1
[INFO] [stdout]     |
[INFO] [stdout]  76 | forward_assign_self!(BigUint, BitOrAssign, bitor_assign);
[INFO] [stdout]     | -------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:255:87
[INFO] [stdout]     |
[INFO] [stdout] 241 | macro_rules! forward_assign_self {
[INFO] [stdout] ...
[INFO] [stdout] 255 |             |lhs: &mut $struct, rhs: &$struct| { $trait::$fn(&mut lhs.0, &rhs.0).into() }
[INFO] [stdout]     |                                                                                       ^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:76:1
[INFO] [stdout]     |
[INFO] [stdout]  76 | forward_assign_self!(BigUint, BitOrAssign, bitor_assign);
[INFO] [stdout]     | -------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:248:85
[INFO] [stdout]     |
[INFO] [stdout] 241 | macro_rules! forward_assign_self {
[INFO] [stdout] ...
[INFO] [stdout] 248 |             |lhs: &mut $struct, rhs: $struct| { $trait::$fn(&mut lhs.0, rhs.0).into() }
[INFO] [stdout]     |                                                                                     ^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:77:1
[INFO] [stdout]     |
[INFO] [stdout]  77 | forward_assign_self!(BigUint, BitXorAssign, bitxor_assign);
[INFO] [stdout]     | ---------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:255:87
[INFO] [stdout]     |
[INFO] [stdout] 241 | macro_rules! forward_assign_self {
[INFO] [stdout] ...
[INFO] [stdout] 255 |             |lhs: &mut $struct, rhs: &$struct| { $trait::$fn(&mut lhs.0, &rhs.0).into() }
[INFO] [stdout]     |                                                                                       ^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/biguint.rs:77:1
[INFO] [stdout]     |
[INFO] [stdout]  77 | forward_assign_self!(BigUint, BitXorAssign, bitxor_assign);
[INFO] [stdout]     | ---------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:13
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:124:1
[INFO] [stdout]     |
[INFO] [stdout] 124 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, AddAssign, add_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:13
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:124:1
[INFO] [stdout]     |
[INFO] [stdout] 124 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, AddAssign, add_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:124:1
[INFO] [stdout]     |
[INFO] [stdout] 124 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, AddAssign, add_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:124:1
[INFO] [stdout]     |
[INFO] [stdout] 124 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, AddAssign, add_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:124:1
[INFO] [stdout]     |
[INFO] [stdout] 124 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, AddAssign, add_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:124:1
[INFO] [stdout]     |
[INFO] [stdout] 124 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, AddAssign, add_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:124:1
[INFO] [stdout]     |
[INFO] [stdout] 124 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, AddAssign, add_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:124:1
[INFO] [stdout]     |
[INFO] [stdout] 124 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, AddAssign, add_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:124:1
[INFO] [stdout]     |
[INFO] [stdout] 124 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, AddAssign, add_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:124:1
[INFO] [stdout]     |
[INFO] [stdout] 124 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, AddAssign, add_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:124:1
[INFO] [stdout]     |
[INFO] [stdout] 124 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, AddAssign, add_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:124:1
[INFO] [stdout]     |
[INFO] [stdout] 124 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, AddAssign, add_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:124:1
[INFO] [stdout]     |
[INFO] [stdout] 124 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, AddAssign, add_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:124:1
[INFO] [stdout]     |
[INFO] [stdout] 124 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, AddAssign, add_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:124:1
[INFO] [stdout]     |
[INFO] [stdout] 124 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, AddAssign, add_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:124:1
[INFO] [stdout]     |
[INFO] [stdout] 124 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, AddAssign, add_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:124:1
[INFO] [stdout]     |
[INFO] [stdout] 124 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, AddAssign, add_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:124:1
[INFO] [stdout]     |
[INFO] [stdout] 124 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, AddAssign, add_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:124:1
[INFO] [stdout]     |
[INFO] [stdout] 124 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, AddAssign, add_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:124:1
[INFO] [stdout]     |
[INFO] [stdout] 124 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, AddAssign, add_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:124:1
[INFO] [stdout]     |
[INFO] [stdout] 124 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, AddAssign, add_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:124:1
[INFO] [stdout]     |
[INFO] [stdout] 124 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, AddAssign, add_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:124:1
[INFO] [stdout]     |
[INFO] [stdout] 124 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, AddAssign, add_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:124:1
[INFO] [stdout]     |
[INFO] [stdout] 124 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, AddAssign, add_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:125:1
[INFO] [stdout]     |
[INFO] [stdout] 125 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, SubAssign, sub_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:125:1
[INFO] [stdout]     |
[INFO] [stdout] 125 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, SubAssign, sub_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:125:1
[INFO] [stdout]     |
[INFO] [stdout] 125 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, SubAssign, sub_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:125:1
[INFO] [stdout]     |
[INFO] [stdout] 125 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, SubAssign, sub_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:125:1
[INFO] [stdout]     |
[INFO] [stdout] 125 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, SubAssign, sub_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:125:1
[INFO] [stdout]     |
[INFO] [stdout] 125 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, SubAssign, sub_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:125:1
[INFO] [stdout]     |
[INFO] [stdout] 125 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, SubAssign, sub_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:125:1
[INFO] [stdout]     |
[INFO] [stdout] 125 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, SubAssign, sub_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:125:1
[INFO] [stdout]     |
[INFO] [stdout] 125 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, SubAssign, sub_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:125:1
[INFO] [stdout]     |
[INFO] [stdout] 125 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, SubAssign, sub_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:125:1
[INFO] [stdout]     |
[INFO] [stdout] 125 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, SubAssign, sub_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:125:1
[INFO] [stdout]     |
[INFO] [stdout] 125 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, SubAssign, sub_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:125:1
[INFO] [stdout]     |
[INFO] [stdout] 125 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, SubAssign, sub_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:125:1
[INFO] [stdout]     |
[INFO] [stdout] 125 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, SubAssign, sub_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:125:1
[INFO] [stdout]     |
[INFO] [stdout] 125 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, SubAssign, sub_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:125:1
[INFO] [stdout]     |
[INFO] [stdout] 125 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, SubAssign, sub_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:125:1
[INFO] [stdout]     |
[INFO] [stdout] 125 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, SubAssign, sub_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:125:1
[INFO] [stdout]     |
[INFO] [stdout] 125 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, SubAssign, sub_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:125:1
[INFO] [stdout]     |
[INFO] [stdout] 125 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, SubAssign, sub_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:125:1
[INFO] [stdout]     |
[INFO] [stdout] 125 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, SubAssign, sub_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:125:1
[INFO] [stdout]     |
[INFO] [stdout] 125 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, SubAssign, sub_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:125:1
[INFO] [stdout]     |
[INFO] [stdout] 125 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, SubAssign, sub_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:125:1
[INFO] [stdout]     |
[INFO] [stdout] 125 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, SubAssign, sub_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:125:1
[INFO] [stdout]     |
[INFO] [stdout] 125 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, SubAssign, sub_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:126:1
[INFO] [stdout]     |
[INFO] [stdout] 126 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, MulAssign, mul_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:126:1
[INFO] [stdout]     |
[INFO] [stdout] 126 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, MulAssign, mul_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:126:1
[INFO] [stdout]     |
[INFO] [stdout] 126 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, MulAssign, mul_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:126:1
[INFO] [stdout]     |
[INFO] [stdout] 126 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, MulAssign, mul_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:126:1
[INFO] [stdout]     |
[INFO] [stdout] 126 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, MulAssign, mul_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:126:1
[INFO] [stdout]     |
[INFO] [stdout] 126 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, MulAssign, mul_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:126:1
[INFO] [stdout]     |
[INFO] [stdout] 126 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, MulAssign, mul_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:126:1
[INFO] [stdout]     |
[INFO] [stdout] 126 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, MulAssign, mul_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:126:1
[INFO] [stdout]     |
[INFO] [stdout] 126 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, MulAssign, mul_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:126:1
[INFO] [stdout]     |
[INFO] [stdout] 126 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, MulAssign, mul_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:126:1
[INFO] [stdout]     |
[INFO] [stdout] 126 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, MulAssign, mul_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:126:1
[INFO] [stdout]     |
[INFO] [stdout] 126 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, MulAssign, mul_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:126:1
[INFO] [stdout]     |
[INFO] [stdout] 126 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, MulAssign, mul_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:126:1
[INFO] [stdout]     |
[INFO] [stdout] 126 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, MulAssign, mul_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:126:1
[INFO] [stdout]     |
[INFO] [stdout] 126 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, MulAssign, mul_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:126:1
[INFO] [stdout]     |
[INFO] [stdout] 126 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, MulAssign, mul_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:126:1
[INFO] [stdout]     |
[INFO] [stdout] 126 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, MulAssign, mul_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:126:1
[INFO] [stdout]     |
[INFO] [stdout] 126 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, MulAssign, mul_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:126:1
[INFO] [stdout]     |
[INFO] [stdout] 126 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, MulAssign, mul_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:126:1
[INFO] [stdout]     |
[INFO] [stdout] 126 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, MulAssign, mul_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:126:1
[INFO] [stdout]     |
[INFO] [stdout] 126 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, MulAssign, mul_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:126:1
[INFO] [stdout]     |
[INFO] [stdout] 126 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, MulAssign, mul_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:126:1
[INFO] [stdout]     |
[INFO] [stdout] 126 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, MulAssign, mul_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:126:1
[INFO] [stdout]     |
[INFO] [stdout] 126 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, MulAssign, mul_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:127:1
[INFO] [stdout]     |
[INFO] [stdout] 127 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, DivAssign, div_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:127:1
[INFO] [stdout]     |
[INFO] [stdout] 127 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, DivAssign, div_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:127:1
[INFO] [stdout]     |
[INFO] [stdout] 127 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, DivAssign, div_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:127:1
[INFO] [stdout]     |
[INFO] [stdout] 127 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, DivAssign, div_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:127:1
[INFO] [stdout]     |
[INFO] [stdout] 127 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, DivAssign, div_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:127:1
[INFO] [stdout]     |
[INFO] [stdout] 127 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, DivAssign, div_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:127:1
[INFO] [stdout]     |
[INFO] [stdout] 127 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, DivAssign, div_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:127:1
[INFO] [stdout]     |
[INFO] [stdout] 127 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, DivAssign, div_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:127:1
[INFO] [stdout]     |
[INFO] [stdout] 127 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, DivAssign, div_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:127:1
[INFO] [stdout]     |
[INFO] [stdout] 127 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, DivAssign, div_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:127:1
[INFO] [stdout]     |
[INFO] [stdout] 127 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, DivAssign, div_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:127:1
[INFO] [stdout]     |
[INFO] [stdout] 127 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, DivAssign, div_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:127:1
[INFO] [stdout]     |
[INFO] [stdout] 127 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, DivAssign, div_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:127:1
[INFO] [stdout]     |
[INFO] [stdout] 127 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, DivAssign, div_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:127:1
[INFO] [stdout]     |
[INFO] [stdout] 127 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, DivAssign, div_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:127:1
[INFO] [stdout]     |
[INFO] [stdout] 127 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, DivAssign, div_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:127:1
[INFO] [stdout]     |
[INFO] [stdout] 127 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, DivAssign, div_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:127:1
[INFO] [stdout]     |
[INFO] [stdout] 127 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, DivAssign, div_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:127:1
[INFO] [stdout]     |
[INFO] [stdout] 127 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, DivAssign, div_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:127:1
[INFO] [stdout]     |
[INFO] [stdout] 127 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, DivAssign, div_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:127:1
[INFO] [stdout]     |
[INFO] [stdout] 127 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, DivAssign, div_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:127:1
[INFO] [stdout]     |
[INFO] [stdout] 127 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, DivAssign, div_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:127:1
[INFO] [stdout]     |
[INFO] [stdout] 127 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, DivAssign, div_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:127:1
[INFO] [stdout]     |
[INFO] [stdout] 127 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, DivAssign, div_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:128:1
[INFO] [stdout]     |
[INFO] [stdout] 128 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, RemAssign, rem_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:128:1
[INFO] [stdout]     |
[INFO] [stdout] 128 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, RemAssign, rem_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:128:1
[INFO] [stdout]     |
[INFO] [stdout] 128 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, RemAssign, rem_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:128:1
[INFO] [stdout]     |
[INFO] [stdout] 128 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, RemAssign, rem_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:128:1
[INFO] [stdout]     |
[INFO] [stdout] 128 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, RemAssign, rem_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:128:1
[INFO] [stdout]     |
[INFO] [stdout] 128 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, RemAssign, rem_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:128:1
[INFO] [stdout]     |
[INFO] [stdout] 128 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, RemAssign, rem_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:128:1
[INFO] [stdout]     |
[INFO] [stdout] 128 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, RemAssign, rem_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:128:1
[INFO] [stdout]     |
[INFO] [stdout] 128 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, RemAssign, rem_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:128:1
[INFO] [stdout]     |
[INFO] [stdout] 128 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, RemAssign, rem_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:128:1
[INFO] [stdout]     |
[INFO] [stdout] 128 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, RemAssign, rem_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:128:1
[INFO] [stdout]     |
[INFO] [stdout] 128 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, RemAssign, rem_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout]     | |                                                               ^
[INFO] [stdout] ...   |
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:128:1
[INFO] [stdout]     |
[INFO] [stdout] 128 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, RemAssign, rem_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:277:64
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[INFO] [stdout] 273 | |         impl_assign_op!($lhs, $rhs, $trait, $fn, |lhs: &mut $lhs, rhs: $rhs| {
[INFO] [stdout] 274 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(rhs).0).into()
[INFO] [stdout] ...   |
[INFO] [stdout] 277 | |             $trait::$fn(&mut lhs.0, <$lhs>::from(*rhs).0).into()
[INFO] [stdout]     | |                                                                ^
[INFO] [stdout] 278 | |         });
[INFO] [stdout] 279 | |     };
[INFO] [stdout] 280 | | }
[INFO] [stdout]     | |_- this error originates in the macro `forward_assign_primitive_into` which comes from the expansion of the macro `apply_to_primitives`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/bigint.rs:128:1
[INFO] [stdout]     |
[INFO] [stdout] 128 |   apply_to_primitives!(forward_assign_primitive_into{BigInt, _, RemAssign, rem_assign});
[INFO] [stdout]     |   ------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<() as Into<()>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `()`
[INFO] [stdout]    --> src/macros.rs:274:63
[INFO] [stdout]     |
[INFO] [stdout] 271 | / macro_rules! forward_assign_primitive_into {
[INFO] [stdout] 272 | |     ($lhs:ty, $rhs:ty, $trait:tt, $fn:ident) => {
[WARN] too many lines in the log, truncating it
