[INFO] fetching crate datalove-rt 0.1.0...
[INFO] checking datalove-rt-0.1.0 against a5689b034ad287112f709693384a37f1377eb9cc for pr-129249-3
[INFO] extracting crate datalove-rt 0.1.0 into /workspace/builds/worker-0-tc2/source
[INFO] started tweaking crates.io crate datalove-rt 0.1.0
[INFO] finished tweaking crates.io crate datalove-rt 0.1.0
[INFO] tweaked toml for crates.io crate datalove-rt 0.1.0 written to /workspace/builds/worker-0-tc2/source/Cargo.toml
[INFO] validating manifest of crates.io crate datalove-rt 0.1.0 on toolchain a5689b034ad287112f709693384a37f1377eb9cc
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "metadata" "--manifest-path" "Cargo.toml" "--no-deps", kill_on_drop: false }`
[INFO] crate crates.io crate datalove-rt 0.1.0 already has a lockfile, it will not be regenerated
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "fetch" "--manifest-path" "Cargo.toml", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-0-tc2/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-0-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] b4c9c20751cb535381f6d7a8070b6e5532a72e356dbd70186791a457cc529da7
[INFO] running `Command { std: "docker" "start" "b4c9c20751cb535381f6d7a8070b6e5532a72e356dbd70186791a457cc529da7", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "b4c9c20751cb535381f6d7a8070b6e5532a72e356dbd70186791a457cc529da7", 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" "b4c9c20751cb535381f6d7a8070b6e5532a72e356dbd70186791a457cc529da7" "/opt/rustwide/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "b4c9c20751cb535381f6d7a8070b6e5532a72e356dbd70186791a457cc529da7", 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" "b4c9c20751cb535381f6d7a8070b6e5532a72e356dbd70186791a457cc529da7" "/opt/rustwide/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "check" "--frozen" "--all" "--all-targets" "--message-format=json", kill_on_drop: false }`
[INFO] [stderr]    Compiling proc-macro2 v1.0.97
[INFO] [stderr]    Compiling phf_shared v0.13.1
[INFO] [stderr]    Compiling fastrand v2.3.0
[INFO] [stderr]    Compiling rustix v1.0.8
[INFO] [stderr]     Checking aho-corasick v1.1.3
[INFO] [stderr]     Checking getrandom v0.3.3
[INFO] [stderr]     Checking bitflags v2.13.1
[INFO] [stderr]    Compiling toml_datetime v0.6.11
[INFO] [stderr]    Compiling winnow v0.7.12
[INFO] [stderr]     Checking once_cell v1.21.3
[INFO] [stderr]    Compiling find-msvc-tools v0.1.8
[INFO] [stderr]     Checking anstream v0.6.20
[INFO] [stderr]    Compiling getrandom v0.2.16
[INFO] [stderr]    Compiling jetscii v0.5.3
[INFO] [stderr]    Compiling entities v1.0.1
[INFO] [stderr]     Checking rand_core v0.9.3
[INFO] [stderr]    Compiling ahash v0.8.12
[INFO] [stderr]    Compiling cc v1.2.53
[INFO] [stderr]    Compiling convert_case v0.7.1
[INFO] [stderr]     Checking unicode-normalization v0.1.24
[INFO] [stderr]     Checking wait-timeout v0.2.1
[INFO] [stderr]     Checking log v0.4.29
[INFO] [stderr]    Compiling const-random-macro v0.1.16
[INFO] [stderr]     Checking simd-adler32 v0.3.7
[INFO] [stderr]     Checking winnow v1.0.4
[INFO] [stderr]    Compiling anyhow v1.0.104
[INFO] [stderr]    Compiling phf_generator v0.13.1
[INFO] [stderr]    Compiling semver v1.0.26
[INFO] [stderr]    Compiling serde_json v1.0.142
[INFO] [stderr]     Checking bit-vec v0.8.0
[INFO] [stderr]    Compiling thiserror v2.0.14
[INFO] [stderr]    Compiling phf_codegen v0.13.1
[INFO] [stderr]     Checking miniz_oxide v0.8.9
[INFO] [stderr]     Checking clap_builder v4.5.44
[INFO] [stderr]     Checking const-random v0.1.18
[INFO] [stderr]     Checking bit-set v0.8.0
[INFO] [stderr]     Checking digest v0.11.3
[INFO] [stderr]     Checking rand v0.9.2
[INFO] [stderr]     Checking rand_xorshift v0.4.0
[INFO] [stderr]     Checking rand_chacha v0.9.0
[INFO] [stderr]     Checking toml_datetime v1.1.1+spec-1.1.0
[INFO] [stderr]     Checking crossbeam-channel v0.5.15
[INFO] [stderr]     Checking serde_spanned v1.1.1
[INFO] [stderr]     Checking crossbeam-queue v0.3.12
[INFO] [stderr]     Checking phf v0.13.1
[INFO] [stderr]    Compiling comrak v0.54.0
[INFO] [stderr]     Checking caseless v0.2.2
[INFO] [stderr]     Checking unarray v0.1.4
[INFO] [stderr]     Checking rustc-hash v2.1.1
[INFO] [stderr]     Checking ucd-trie v0.1.7
[INFO] [stderr]     Checking toml_writer v1.1.2+spec-1.1.0
[INFO] [stderr]     Checking finl_unicode v1.4.0
[INFO] [stderr]     Checking typed-path v0.12.3
[INFO] [stderr]     Checking chrono v0.4.41
[INFO] [stderr]     Checking sha2 v0.11.0
[INFO] [stderr]     Checking toml_parser v1.1.3+spec-1.1.0
[INFO] [stderr]    Compiling quote v1.0.40
[INFO] [stderr]     Checking flate2 v1.1.4
[INFO] [stderr]     Checking itertools v0.15.0
[INFO] [stderr]    Compiling syn v2.0.106
[INFO] [stderr]     Checking crossbeam v0.8.4
[INFO] [stderr]     Checking nom v8.0.0
[INFO] [stderr]     Checking powerletters v0.3.0
[INFO] [stderr]     Checking base64 v0.23.1
[INFO] [stderr]     Checking regex-automata v0.4.9
[INFO] [stderr]     Checking toml v1.1.4+spec-1.1.0
[INFO] [stderr]     Checking datalove-rtdt v0.1.0
[INFO] [stderr]     Checking datalove-rti v0.1.0
[INFO] [stderr]    Compiling blake3 v1.8.2
[INFO] [stderr]     Checking zip v8.6.0
[INFO] [stderr]     Checking tempfile v3.20.0
[INFO] [stderr]    Compiling toml_edit v0.22.27
[INFO] [stderr]     Checking rusty-fork v0.3.0
[INFO] [stderr]     Checking proptest v1.7.0
[INFO] [stderr]     Checking regex v1.11.1
[INFO] [stderr]     Checking env_filter v0.1.3
[INFO] [stderr]    Compiling proc-macro-crate v3.3.0
[INFO] [stderr]    Compiling serde_derive v1.0.228
[INFO] [stderr]    Compiling futures-macro v0.3.31
[INFO] [stderr]    Compiling thiserror-impl v2.0.14
[INFO] [stderr]    Compiling clap_derive v4.5.45
[INFO] [stderr]    Compiling num_enum_derive v0.7.4
[INFO] [stderr]    Compiling derive_more-impl v2.0.1
[INFO] [stderr]    Compiling extension-trait v1.0.2
[INFO] [stderr]     Checking futures-util v0.3.31
[INFO] [stderr]     Checking num_enum v0.7.4
[INFO] [stderr]     Checking clap v4.5.45
[INFO] [stderr]     Checking serde v1.0.228
[INFO] [stderr]     Checking jiff v0.2.15
[INFO] [stderr]     Checking rand_chacha v0.10.0
[INFO] [stderr]     Checking rand v0.10.2
[INFO] [stderr]     Checking num-bigint v0.5.1
[INFO] [stderr]     Checking tera v2.2.0
[INFO] [stderr]     Checking json5 v1.3.0
[INFO] [stderr]     Checking hex v0.4.3
[INFO] [stderr]     Checking bytes v1.10.1
[INFO] [stderr]     Checking rand_pcg v0.10.2
[INFO] [stderr]     Checking derive_more v2.0.1
[INFO] [stderr]     Checking futures-executor v0.3.31
[INFO] [stderr]     Checking futures v0.3.31
[INFO] [stderr]     Checking env_logger v0.11.8
[INFO] [stderr]     Checking rustmax v0.0.10
[INFO] [stderr]     Checking datalove-rt v0.1.0 (/opt/rustwide/workdir)
[INFO] [stdout] warning: variable does not need to be mutable
[INFO] [stdout]    --> src/impls/list.rs:598:9
[INFO] [stdout]     |
[INFO] [stdout] 598 |     let mut list = unsafe { ListMut::new(list_value_mut as *mut List, element_ty) };
[INFO] [stdout]     |         ----^^^^
[INFO] [stdout]     |         |
[INFO] [stdout]     |         help: remove this `mut`
[INFO] [stdout]     |
[INFO] [stdout]     = note: `#[warn(unused_mut)]` (part of `#[warn(unused)]`) on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]   --> src/rust/mod.rs:72:75
[INFO] [stdout]    |
[INFO] [stdout] 72 |         let ptr = unsafe { crate::c::dtlv_rti_mem_alloc_local(rt, tydesc, count.into()) };
[INFO] [stdout]    |                                                                           ^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: `#[deny(self_type_conversion)]` on by default
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 72 -         let ptr = unsafe { crate::c::dtlv_rti_mem_alloc_local(rt, tydesc, count.into()) };
[INFO] [stdout] 72 +         let ptr = unsafe { crate::c::dtlv_rti_mem_alloc_local(rt, tydesc, count) };
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 72 -         let ptr = unsafe { crate::c::dtlv_rti_mem_alloc_local(rt, tydesc, count.into()) };
[INFO] [stdout] 72 +         let ptr = unsafe { crate::c::dtlv_rti_mem_alloc_local(rt, tydesc, <u32 as Into<_>>::into(count)) };
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/rust/mod.rs:118:69
[INFO] [stdout]     |
[INFO] [stdout] 118 |             crate::c::dtlv_rti_mem_free_local(self.rt, self.tydesc, self.count.into(), self.ptr);
[INFO] [stdout]     |                                                                     ^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 118 -             crate::c::dtlv_rti_mem_free_local(self.rt, self.tydesc, self.count.into(), self.ptr);
[INFO] [stdout] 118 +             crate::c::dtlv_rti_mem_free_local(self.rt, self.tydesc, self.count, self.ptr);
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 118 -             crate::c::dtlv_rti_mem_free_local(self.rt, self.tydesc, self.count.into(), self.ptr);
[INFO] [stdout] 118 +             crate::c::dtlv_rti_mem_free_local(self.rt, self.tydesc, <u32 as Into<_>>::into(self.count), self.ptr);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]   --> src/impls/clone.rs:68:83
[INFO] [stdout]    |
[INFO] [stdout] 68 |                 let new_data = unsafe { rt_ref.alloc.alloc(limb_size, limb_align, num_limbs.into()) as *mut u32 };
[INFO] [stdout]    |                                                                                   ^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 68 -                 let new_data = unsafe { rt_ref.alloc.alloc(limb_size, limb_align, num_limbs.into()) as *mut u32 };
[INFO] [stdout] 68 +                 let new_data = unsafe { rt_ref.alloc.alloc(limb_size, limb_align, num_limbs) as *mut u32 };
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 68 -                 let new_data = unsafe { rt_ref.alloc.alloc(limb_size, limb_align, num_limbs.into()) as *mut u32 };
[INFO] [stdout] 68 +                 let new_data = unsafe { rt_ref.alloc.alloc(limb_size, limb_align, <u32 as Into<_>>::into(num_limbs)) as *mut u32 };
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/impls/clone.rs:713:65
[INFO] [stdout]     |
[INFO] [stdout] 713 |         rt_ref.alloc.alloc(rtdt::INDEX_SIZE, rtdt::INDEX_ALIGN, rank.into())
[INFO] [stdout]     |                                                                 ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 713 -         rt_ref.alloc.alloc(rtdt::INDEX_SIZE, rtdt::INDEX_ALIGN, rank.into())
[INFO] [stdout] 713 +         rt_ref.alloc.alloc(rtdt::INDEX_SIZE, rtdt::INDEX_ALIGN, rank)
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 713 -         rt_ref.alloc.alloc(rtdt::INDEX_SIZE, rtdt::INDEX_ALIGN, rank.into())
[INFO] [stdout] 713 +         rt_ref.alloc.alloc(rtdt::INDEX_SIZE, rtdt::INDEX_ALIGN, <u32 as Into<_>>::into(rank))
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/impls/clone.rs:722:65
[INFO] [stdout]     |
[INFO] [stdout] 722 |         rt_ref.alloc.alloc(rtdt::INDEX_SIZE, rtdt::INDEX_ALIGN, rank.into())
[INFO] [stdout]     |                                                                 ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 722 -         rt_ref.alloc.alloc(rtdt::INDEX_SIZE, rtdt::INDEX_ALIGN, rank.into())
[INFO] [stdout] 722 +         rt_ref.alloc.alloc(rtdt::INDEX_SIZE, rtdt::INDEX_ALIGN, rank)
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 722 -         rt_ref.alloc.alloc(rtdt::INDEX_SIZE, rtdt::INDEX_ALIGN, rank.into())
[INFO] [stdout] 722 +         rt_ref.alloc.alloc(rtdt::INDEX_SIZE, rtdt::INDEX_ALIGN, <u32 as Into<_>>::into(rank))
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/impls/clone.rs:727:68
[INFO] [stdout]     |
[INFO] [stdout] 727 |             rt_ref.alloc.free(rtdt::INDEX_SIZE, rtdt::INDEX_ALIGN, rank.into(), new_shape as *mut u8);
[INFO] [stdout]     |                                                                    ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 727 -             rt_ref.alloc.free(rtdt::INDEX_SIZE, rtdt::INDEX_ALIGN, rank.into(), new_shape as *mut u8);
[INFO] [stdout] 727 +             rt_ref.alloc.free(rtdt::INDEX_SIZE, rtdt::INDEX_ALIGN, rank, new_shape as *mut u8);
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 727 -             rt_ref.alloc.free(rtdt::INDEX_SIZE, rtdt::INDEX_ALIGN, rank.into(), new_shape as *mut u8);
[INFO] [stdout] 727 +             rt_ref.alloc.free(rtdt::INDEX_SIZE, rtdt::INDEX_ALIGN, <u32 as Into<_>>::into(rank), new_shape as *mut u8);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/impls/clone.rs:780:72
[INFO] [stdout]     |
[INFO] [stdout] 780 |                 rt_ref.alloc.free(rtdt::INDEX_SIZE, rtdt::INDEX_ALIGN, rank.into(), new_shape as *mut u8);
[INFO] [stdout]     |                                                                        ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 780 -                 rt_ref.alloc.free(rtdt::INDEX_SIZE, rtdt::INDEX_ALIGN, rank.into(), new_shape as *mut u8);
[INFO] [stdout] 780 +                 rt_ref.alloc.free(rtdt::INDEX_SIZE, rtdt::INDEX_ALIGN, rank, new_shape as *mut u8);
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 780 -                 rt_ref.alloc.free(rtdt::INDEX_SIZE, rtdt::INDEX_ALIGN, rank.into(), new_shape as *mut u8);
[INFO] [stdout] 780 +                 rt_ref.alloc.free(rtdt::INDEX_SIZE, rtdt::INDEX_ALIGN, <u32 as Into<_>>::into(rank), new_shape as *mut u8);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/impls/clone.rs:781:72
[INFO] [stdout]     |
[INFO] [stdout] 781 |                 rt_ref.alloc.free(rtdt::INDEX_SIZE, rtdt::INDEX_ALIGN, rank.into(), new_strides as *mut u8);
[INFO] [stdout]     |                                                                        ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 781 -                 rt_ref.alloc.free(rtdt::INDEX_SIZE, rtdt::INDEX_ALIGN, rank.into(), new_strides as *mut u8);
[INFO] [stdout] 781 +                 rt_ref.alloc.free(rtdt::INDEX_SIZE, rtdt::INDEX_ALIGN, rank, new_strides as *mut u8);
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 781 -                 rt_ref.alloc.free(rtdt::INDEX_SIZE, rtdt::INDEX_ALIGN, rank.into(), new_strides as *mut u8);
[INFO] [stdout] 781 +                 rt_ref.alloc.free(rtdt::INDEX_SIZE, rtdt::INDEX_ALIGN, <u32 as Into<_>>::into(rank), new_strides as *mut u8);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/impls/clone.rs:1565:75
[INFO] [stdout]      |
[INFO] [stdout] 1565 |         let dst = rt_ref.alloc.alloc(rtdt::INDEX_SIZE, rtdt::INDEX_ALIGN, rank.into()) as *mut rtdt::Index;
[INFO] [stdout]      |                                                                           ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1565 -         let dst = rt_ref.alloc.alloc(rtdt::INDEX_SIZE, rtdt::INDEX_ALIGN, rank.into()) as *mut rtdt::Index;
[INFO] [stdout] 1565 +         let dst = rt_ref.alloc.alloc(rtdt::INDEX_SIZE, rtdt::INDEX_ALIGN, rank) as *mut rtdt::Index;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1565 -         let dst = rt_ref.alloc.alloc(rtdt::INDEX_SIZE, rtdt::INDEX_ALIGN, rank.into()) as *mut rtdt::Index;
[INFO] [stdout] 1565 +         let dst = rt_ref.alloc.alloc(rtdt::INDEX_SIZE, rtdt::INDEX_ALIGN, <u32 as Into<_>>::into(rank)) as *mut rtdt::Index;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/impls/tensor.rs:343:13
[INFO] [stdout]     |
[INFO] [stdout] 343 |             rank.into(),
[INFO] [stdout]     |             ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 343 -             rank.into(),
[INFO] [stdout] 343 +             rank,
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 343 -             rank.into(),
[INFO] [stdout] 343 +             <u32 as Into<_>>::into(rank),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/impls/tensor.rs:360:13
[INFO] [stdout]     |
[INFO] [stdout] 360 |             rank.into(),
[INFO] [stdout]     |             ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 360 -             rank.into(),
[INFO] [stdout] 360 +             rank,
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 360 -             rank.into(),
[INFO] [stdout] 360 +             <u32 as Into<_>>::into(rank),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/impls/tensor.rs:369:17
[INFO] [stdout]     |
[INFO] [stdout] 369 |                 rank.into(),
[INFO] [stdout]     |                 ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 369 -                 rank.into(),
[INFO] [stdout] 369 +                 rank,
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 369 -                 rank.into(),
[INFO] [stdout] 369 +                 <u32 as Into<_>>::into(rank),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/impls/tensor.rs:590:13
[INFO] [stdout]     |
[INFO] [stdout] 590 |             rank.into(),
[INFO] [stdout]     |             ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 590 -             rank.into(),
[INFO] [stdout] 590 +             rank,
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 590 -             rank.into(),
[INFO] [stdout] 590 +             <u32 as Into<_>>::into(rank),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/impls/tensor.rs:600:13
[INFO] [stdout]     |
[INFO] [stdout] 600 |             rank.into(),
[INFO] [stdout]     |             ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 600 -             rank.into(),
[INFO] [stdout] 600 +             rank,
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 600 -             rank.into(),
[INFO] [stdout] 600 +             <u32 as Into<_>>::into(rank),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/impls/tensor.rs:606:17
[INFO] [stdout]     |
[INFO] [stdout] 606 |                 rank.into(),
[INFO] [stdout]     |                 ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 606 -                 rank.into(),
[INFO] [stdout] 606 +                 rank,
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 606 -                 rank.into(),
[INFO] [stdout] 606 +                 <u32 as Into<_>>::into(rank),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/impls/tensor.rs:645:13
[INFO] [stdout]     |
[INFO] [stdout] 645 |             rank.into(),
[INFO] [stdout]     |             ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 645 -             rank.into(),
[INFO] [stdout] 645 +             rank,
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 645 -             rank.into(),
[INFO] [stdout] 645 +             <u32 as Into<_>>::into(rank),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/impls/tensor.rs:651:13
[INFO] [stdout]     |
[INFO] [stdout] 651 |             rank.into(),
[INFO] [stdout]     |             ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 651 -             rank.into(),
[INFO] [stdout] 651 +             rank,
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 651 -             rank.into(),
[INFO] [stdout] 651 +             <u32 as Into<_>>::into(rank),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/impls/tensor.rs:741:17
[INFO] [stdout]     |
[INFO] [stdout] 741 |                 rank.into(),
[INFO] [stdout]     |                 ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 741 -                 rank.into(),
[INFO] [stdout] 741 +                 rank,
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 741 -                 rank.into(),
[INFO] [stdout] 741 +                 <u32 as Into<_>>::into(rank),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/impls/tensor.rs:751:17
[INFO] [stdout]     |
[INFO] [stdout] 751 |                 rank.into(),
[INFO] [stdout]     |                 ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 751 -                 rank.into(),
[INFO] [stdout] 751 +                 rank,
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 751 -                 rank.into(),
[INFO] [stdout] 751 +                 <u32 as Into<_>>::into(rank),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/impls/tensor.rs:824:13
[INFO] [stdout]     |
[INFO] [stdout] 824 |             sub_rank.into(),
[INFO] [stdout]     |             ^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 824 -             sub_rank.into(),
[INFO] [stdout] 824 +             sub_rank,
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 824 -             sub_rank.into(),
[INFO] [stdout] 824 +             <u32 as Into<_>>::into(sub_rank),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/impls/tensor.rs:835:13
[INFO] [stdout]     |
[INFO] [stdout] 835 |             sub_rank.into(),
[INFO] [stdout]     |             ^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 835 -             sub_rank.into(),
[INFO] [stdout] 835 +             sub_rank,
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 835 -             sub_rank.into(),
[INFO] [stdout] 835 +             <u32 as Into<_>>::into(sub_rank),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/impls/tensor.rs:842:17
[INFO] [stdout]     |
[INFO] [stdout] 842 |                 sub_rank.into(),
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 842 -                 sub_rank.into(),
[INFO] [stdout] 842 +                 sub_rank,
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 842 -                 sub_rank.into(),
[INFO] [stdout] 842 +                 <u32 as Into<_>>::into(sub_rank),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/impls/tensor.rs:911:21
[INFO] [stdout]     |
[INFO] [stdout] 911 |                     sub_rank.into(),
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 911 -                     sub_rank.into(),
[INFO] [stdout] 911 +                     sub_rank,
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 911 -                     sub_rank.into(),
[INFO] [stdout] 911 +                     <u32 as Into<_>>::into(sub_rank),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/impls/tensor.rs:917:21
[INFO] [stdout]     |
[INFO] [stdout] 917 |                     sub_rank.into(),
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 917 -                     sub_rank.into(),
[INFO] [stdout] 917 +                     sub_rank,
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 917 -                     sub_rank.into(),
[INFO] [stdout] 917 +                     <u32 as Into<_>>::into(sub_rank),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/impls/tensor.rs:1024:13
[INFO] [stdout]      |
[INFO] [stdout] 1024 |             rank.into(),
[INFO] [stdout]      |             ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1024 -             rank.into(),
[INFO] [stdout] 1024 +             rank,
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1024 -             rank.into(),
[INFO] [stdout] 1024 +             <u32 as Into<_>>::into(rank),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/impls/tensor.rs:1041:13
[INFO] [stdout]      |
[INFO] [stdout] 1041 |             rank.into(),
[INFO] [stdout]      |             ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1041 -             rank.into(),
[INFO] [stdout] 1041 +             rank,
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1041 -             rank.into(),
[INFO] [stdout] 1041 +             <u32 as Into<_>>::into(rank),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/impls/tensor.rs:1049:17
[INFO] [stdout]      |
[INFO] [stdout] 1049 |                 rank.into(),
[INFO] [stdout]      |                 ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1049 -                 rank.into(),
[INFO] [stdout] 1049 +                 rank,
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1049 -                 rank.into(),
[INFO] [stdout] 1049 +                 <u32 as Into<_>>::into(rank),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/impls/tensor.rs:1080:13
[INFO] [stdout]      |
[INFO] [stdout] 1080 |             rank.into(),
[INFO] [stdout]      |             ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1080 -             rank.into(),
[INFO] [stdout] 1080 +             rank,
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1080 -             rank.into(),
[INFO] [stdout] 1080 +             <u32 as Into<_>>::into(rank),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/impls/tensor.rs:1086:13
[INFO] [stdout]      |
[INFO] [stdout] 1086 |             rank.into(),
[INFO] [stdout]      |             ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1086 -             rank.into(),
[INFO] [stdout] 1086 +             rank,
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1086 -             rank.into(),
[INFO] [stdout] 1086 +             <u32 as Into<_>>::into(rank),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/impls/tensor.rs:1277:64
[INFO] [stdout]      |
[INFO] [stdout] 1277 |         rt_ref.alloc.free(rtdt::INDEX_SIZE, rtdt::INDEX_ALIGN, rank.into(), strides_ptr as *mut u8);
[INFO] [stdout]      |                                                                ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1277 -         rt_ref.alloc.free(rtdt::INDEX_SIZE, rtdt::INDEX_ALIGN, rank.into(), strides_ptr as *mut u8);
[INFO] [stdout] 1277 +         rt_ref.alloc.free(rtdt::INDEX_SIZE, rtdt::INDEX_ALIGN, rank, strides_ptr as *mut u8);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1277 -         rt_ref.alloc.free(rtdt::INDEX_SIZE, rtdt::INDEX_ALIGN, rank.into(), strides_ptr as *mut u8);
[INFO] [stdout] 1277 +         rt_ref.alloc.free(rtdt::INDEX_SIZE, rtdt::INDEX_ALIGN, <u32 as Into<_>>::into(rank), strides_ptr as *mut u8);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/impls/tensor.rs:1280:64
[INFO] [stdout]      |
[INFO] [stdout] 1280 |         rt_ref.alloc.free(rtdt::INDEX_SIZE, rtdt::INDEX_ALIGN, rank.into(), shape_ptr as *mut u8);
[INFO] [stdout]      |                                                                ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1280 -         rt_ref.alloc.free(rtdt::INDEX_SIZE, rtdt::INDEX_ALIGN, rank.into(), shape_ptr as *mut u8);
[INFO] [stdout] 1280 +         rt_ref.alloc.free(rtdt::INDEX_SIZE, rtdt::INDEX_ALIGN, rank, shape_ptr as *mut u8);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1280 -         rt_ref.alloc.free(rtdt::INDEX_SIZE, rtdt::INDEX_ALIGN, rank.into(), shape_ptr as *mut u8);
[INFO] [stdout] 1280 +         rt_ref.alloc.free(rtdt::INDEX_SIZE, rtdt::INDEX_ALIGN, <u32 as Into<_>>::into(rank), shape_ptr as *mut u8);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/impls/destroy.rs:137:76
[INFO] [stdout]     |
[INFO] [stdout] 137 |                     rt_ref.alloc.free(rtdt::INDEX_SIZE, rtdt::INDEX_ALIGN, rank.into(), tensor.shape as *mut u8);
[INFO] [stdout]     |                                                                            ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 137 -                     rt_ref.alloc.free(rtdt::INDEX_SIZE, rtdt::INDEX_ALIGN, rank.into(), tensor.shape as *mut u8);
[INFO] [stdout] 137 +                     rt_ref.alloc.free(rtdt::INDEX_SIZE, rtdt::INDEX_ALIGN, rank, tensor.shape as *mut u8);
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 137 -                     rt_ref.alloc.free(rtdt::INDEX_SIZE, rtdt::INDEX_ALIGN, rank.into(), tensor.shape as *mut u8);
[INFO] [stdout] 137 +                     rt_ref.alloc.free(rtdt::INDEX_SIZE, rtdt::INDEX_ALIGN, <u32 as Into<_>>::into(rank), tensor.shape as *mut u8);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/impls/destroy.rs:142:76
[INFO] [stdout]     |
[INFO] [stdout] 142 |                     rt_ref.alloc.free(rtdt::INDEX_SIZE, rtdt::INDEX_ALIGN, rank.into(), tensor.strides as *mut u8);
[INFO] [stdout]     |                                                                            ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 142 -                     rt_ref.alloc.free(rtdt::INDEX_SIZE, rtdt::INDEX_ALIGN, rank.into(), tensor.strides as *mut u8);
[INFO] [stdout] 142 +                     rt_ref.alloc.free(rtdt::INDEX_SIZE, rtdt::INDEX_ALIGN, rank, tensor.strides as *mut u8);
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 142 -                     rt_ref.alloc.free(rtdt::INDEX_SIZE, rtdt::INDEX_ALIGN, rank.into(), tensor.strides as *mut u8);
[INFO] [stdout] 142 +                     rt_ref.alloc.free(rtdt::INDEX_SIZE, rtdt::INDEX_ALIGN, <u32 as Into<_>>::into(rank), tensor.strides as *mut u8);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]   --> src/impls/int_math.rs:51:47
[INFO] [stdout]    |
[INFO] [stdout] 51 |         let result_ptr = rt.alloc.alloc(4, 4, (result_len as u32).into()) as *mut u32;
[INFO] [stdout]    |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 51 -         let result_ptr = rt.alloc.alloc(4, 4, (result_len as u32).into()) as *mut u32;
[INFO] [stdout] 51 +         let result_ptr = rt.alloc.alloc(4, 4, (result_len as u32)) as *mut u32;
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 51 -         let result_ptr = rt.alloc.alloc(4, 4, (result_len as u32).into()) as *mut u32;
[INFO] [stdout] 51 +         let result_ptr = rt.alloc.alloc(4, 4, <u32 as Into<_>>::into((result_len as u32))) as *mut u32;
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]   --> src/impls/int_math.rs:94:47
[INFO] [stdout]    |
[INFO] [stdout] 94 |         let result_ptr = rt.alloc.alloc(4, 4, (result_len as u32).into()) as *mut u32;
[INFO] [stdout]    |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 94 -         let result_ptr = rt.alloc.alloc(4, 4, (result_len as u32).into()) as *mut u32;
[INFO] [stdout] 94 +         let result_ptr = rt.alloc.alloc(4, 4, (result_len as u32)) as *mut u32;
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 94 -         let result_ptr = rt.alloc.alloc(4, 4, (result_len as u32).into()) as *mut u32;
[INFO] [stdout] 94 +         let result_ptr = rt.alloc.alloc(4, 4, <u32 as Into<_>>::into((result_len as u32))) as *mut u32;
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/impls/int_math.rs:201:52
[INFO] [stdout]     |
[INFO] [stdout] 201 |         let neg_b_limbs_ptr = rt.alloc.alloc(4, 4, (b_abs_size as u32).into()) as *mut u32;
[INFO] [stdout]     |                                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 201 -         let neg_b_limbs_ptr = rt.alloc.alloc(4, 4, (b_abs_size as u32).into()) as *mut u32;
[INFO] [stdout] 201 +         let neg_b_limbs_ptr = rt.alloc.alloc(4, 4, (b_abs_size as u32)) as *mut u32;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 201 -         let neg_b_limbs_ptr = rt.alloc.alloc(4, 4, (b_abs_size as u32).into()) as *mut u32;
[INFO] [stdout] 201 +         let neg_b_limbs_ptr = rt.alloc.alloc(4, 4, <u32 as Into<_>>::into((b_abs_size as u32))) as *mut u32;
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/impls/int_math.rs:217:29
[INFO] [stdout]     |
[INFO] [stdout] 217 |         rt.alloc.free(4, 4, (b_abs_size as u32).into(), neg_b_limbs_ptr as *mut u8);
[INFO] [stdout]     |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 217 -         rt.alloc.free(4, 4, (b_abs_size as u32).into(), neg_b_limbs_ptr as *mut u8);
[INFO] [stdout] 217 +         rt.alloc.free(4, 4, (b_abs_size as u32), neg_b_limbs_ptr as *mut u8);
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 217 -         rt.alloc.free(4, 4, (b_abs_size as u32).into(), neg_b_limbs_ptr as *mut u8);
[INFO] [stdout] 217 +         rt.alloc.free(4, 4, <u32 as Into<_>>::into((b_abs_size as u32)), neg_b_limbs_ptr as *mut u8);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/impls/int_math.rs:277:47
[INFO] [stdout]     |
[INFO] [stdout] 277 |         let result_ptr = rt.alloc.alloc(4, 4, (result_len as u32).into()) as *mut u32;
[INFO] [stdout]     |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 277 -         let result_ptr = rt.alloc.alloc(4, 4, (result_len as u32).into()) as *mut u32;
[INFO] [stdout] 277 +         let result_ptr = rt.alloc.alloc(4, 4, (result_len as u32)) as *mut u32;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 277 -         let result_ptr = rt.alloc.alloc(4, 4, (result_len as u32).into()) as *mut u32;
[INFO] [stdout] 277 +         let result_ptr = rt.alloc.alloc(4, 4, <u32 as Into<_>>::into((result_len as u32))) as *mut u32;
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/impls/int_math.rs:319:46
[INFO] [stdout]     |
[INFO] [stdout] 319 |         let limbs_ptr = rt.alloc.alloc(4, 4, (abs_size as u32).into()) as *mut u32;
[INFO] [stdout]     |                                              ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 319 -         let limbs_ptr = rt.alloc.alloc(4, 4, (abs_size as u32).into()) as *mut u32;
[INFO] [stdout] 319 +         let limbs_ptr = rt.alloc.alloc(4, 4, (abs_size as u32)) as *mut u32;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 319 -         let limbs_ptr = rt.alloc.alloc(4, 4, (abs_size as u32).into()) as *mut u32;
[INFO] [stdout] 319 +         let limbs_ptr = rt.alloc.alloc(4, 4, <u32 as Into<_>>::into((abs_size as u32))) as *mut u32;
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/impls/int_math.rs:380:46
[INFO] [stdout]     |
[INFO] [stdout] 380 |             let q_ptr = rt.alloc.alloc(4, 4, (q_len as u32).into()) as *mut u32;
[INFO] [stdout]     |                                              ^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 380 -             let q_ptr = rt.alloc.alloc(4, 4, (q_len as u32).into()) as *mut u32;
[INFO] [stdout] 380 +             let q_ptr = rt.alloc.alloc(4, 4, (q_len as u32)) as *mut u32;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 380 -             let q_ptr = rt.alloc.alloc(4, 4, (q_len as u32).into()) as *mut u32;
[INFO] [stdout] 380 +             let q_ptr = rt.alloc.alloc(4, 4, <u32 as Into<_>>::into((q_len as u32))) as *mut u32;
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/impls/int_math.rs:488:46
[INFO] [stdout]     |
[INFO] [stdout] 488 |             let q_ptr = rt.alloc.alloc(4, 4, (q_len as u32).into()) as *mut u32;
[INFO] [stdout]     |                                              ^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 488 -             let q_ptr = rt.alloc.alloc(4, 4, (q_len as u32).into()) as *mut u32;
[INFO] [stdout] 488 +             let q_ptr = rt.alloc.alloc(4, 4, (q_len as u32)) as *mut u32;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 488 -             let q_ptr = rt.alloc.alloc(4, 4, (q_len as u32).into()) as *mut u32;
[INFO] [stdout] 488 +             let q_ptr = rt.alloc.alloc(4, 4, <u32 as Into<_>>::into((q_len as u32))) as *mut u32;
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `datalove-rt` (lib) due to 41 previous errors; 1 warning emitted
[INFO] [stderr] warning: build failed, waiting for other jobs to finish...
[INFO] [stdout] warning: variable does not need to be mutable
[INFO] [stdout]    --> src/impls/list.rs:598:9
[INFO] [stdout]     |
[INFO] [stdout] 598 |     let mut list = unsafe { ListMut::new(list_value_mut as *mut List, element_ty) };
[INFO] [stdout]     |         ----^^^^
[INFO] [stdout]     |         |
[INFO] [stdout]     |         help: remove this `mut`
[INFO] [stdout]     |
[INFO] [stdout]     = note: `#[warn(unused_mut)]` (part of `#[warn(unused)]`) on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]   --> src/rust/mod.rs:72:75
[INFO] [stdout]    |
[INFO] [stdout] 72 |         let ptr = unsafe { crate::c::dtlv_rti_mem_alloc_local(rt, tydesc, count.into()) };
[INFO] [stdout]    |                                                                           ^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: `#[deny(self_type_conversion)]` on by default
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 72 -         let ptr = unsafe { crate::c::dtlv_rti_mem_alloc_local(rt, tydesc, count.into()) };
[INFO] [stdout] 72 +         let ptr = unsafe { crate::c::dtlv_rti_mem_alloc_local(rt, tydesc, count) };
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 72 -         let ptr = unsafe { crate::c::dtlv_rti_mem_alloc_local(rt, tydesc, count.into()) };
[INFO] [stdout] 72 +         let ptr = unsafe { crate::c::dtlv_rti_mem_alloc_local(rt, tydesc, <u32 as Into<_>>::into(count)) };
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/rust/mod.rs:118:69
[INFO] [stdout]     |
[INFO] [stdout] 118 |             crate::c::dtlv_rti_mem_free_local(self.rt, self.tydesc, self.count.into(), self.ptr);
[INFO] [stdout]     |                                                                     ^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 118 -             crate::c::dtlv_rti_mem_free_local(self.rt, self.tydesc, self.count.into(), self.ptr);
[INFO] [stdout] 118 +             crate::c::dtlv_rti_mem_free_local(self.rt, self.tydesc, self.count, self.ptr);
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 118 -             crate::c::dtlv_rti_mem_free_local(self.rt, self.tydesc, self.count.into(), self.ptr);
[INFO] [stdout] 118 +             crate::c::dtlv_rti_mem_free_local(self.rt, self.tydesc, <u32 as Into<_>>::into(self.count), self.ptr);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/impls/alloc.rs:874:49
[INFO] [stdout]     |
[INFO] [stdout] 874 |                 let ptr = rt.alloc(size, align, count.into());
[INFO] [stdout]     |                                                 ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 874 -                 let ptr = rt.alloc(size, align, count.into());
[INFO] [stdout] 874 +                 let ptr = rt.alloc(size, align, count);
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 874 -                 let ptr = rt.alloc(size, align, count.into());
[INFO] [stdout] 874 +                 let ptr = rt.alloc(size, align, <u32 as Into<_>>::into(count));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/impls/alloc.rs:878:38
[INFO] [stdout]     |
[INFO] [stdout] 878 |                 rt.free(size, align, count.into(), ptr);
[INFO] [stdout]     |                                      ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 878 -                 rt.free(size, align, count.into(), ptr);
[INFO] [stdout] 878 +                 rt.free(size, align, count, ptr);
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 878 -                 rt.free(size, align, count.into(), ptr);
[INFO] [stdout] 878 +                 rt.free(size, align, <u32 as Into<_>>::into(count), ptr);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/impls/alloc.rs:917:49
[INFO] [stdout]     |
[INFO] [stdout] 917 |                 let ptr = rt.alloc(size, align, 1u32.into());
[INFO] [stdout]     |                                                 ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 917 -                 let ptr = rt.alloc(size, align, 1u32.into());
[INFO] [stdout] 917 +                 let ptr = rt.alloc(size, align, 1u32);
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 917 -                 let ptr = rt.alloc(size, align, 1u32.into());
[INFO] [stdout] 917 +                 let ptr = rt.alloc(size, align, <u32 as Into<_>>::into(1u32));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/impls/alloc.rs:921:38
[INFO] [stdout]     |
[INFO] [stdout] 921 |                 rt.free(size, align, 1u32.into(), ptr);
[INFO] [stdout]     |                                      ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 921 -                 rt.free(size, align, 1u32.into(), ptr);
[INFO] [stdout] 921 +                 rt.free(size, align, 1u32, ptr);
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 921 -                 rt.free(size, align, 1u32.into(), ptr);
[INFO] [stdout] 921 +                 rt.free(size, align, <u32 as Into<_>>::into(1u32), ptr);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/impls/alloc.rs:935:50
[INFO] [stdout]     |
[INFO] [stdout] 935 |                     let ptr = rt.alloc(*size, 8, (*count).into());
[INFO] [stdout]     |                                                  ^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 935 -                     let ptr = rt.alloc(*size, 8, (*count).into());
[INFO] [stdout] 935 +                     let ptr = rt.alloc(*size, 8, (*count));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 935 -                     let ptr = rt.alloc(*size, 8, (*count).into());
[INFO] [stdout] 935 +                     let ptr = rt.alloc(*size, 8, <u32 as Into<_>>::into((*count)));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/impls/alloc.rs:941:39
[INFO] [stdout]     |
[INFO] [stdout] 941 |                     rt.free(*size, 8, (*count).into(), *ptr);
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 941 -                     rt.free(*size, 8, (*count).into(), *ptr);
[INFO] [stdout] 941 +                     rt.free(*size, 8, (*count), *ptr);
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 941 -                     rt.free(*size, 8, (*count).into(), *ptr);
[INFO] [stdout] 941 +                     rt.free(*size, 8, <u32 as Into<_>>::into((*count)), *ptr);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/impls/alloc.rs:958:53
[INFO] [stdout]     |
[INFO] [stdout] 958 |                     let ptr = rt.alloc(size, align, 1u32.into());
[INFO] [stdout]     |                                                     ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 958 -                     let ptr = rt.alloc(size, align, 1u32.into());
[INFO] [stdout] 958 +                     let ptr = rt.alloc(size, align, 1u32);
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 958 -                     let ptr = rt.alloc(size, align, 1u32.into());
[INFO] [stdout] 958 +                     let ptr = rt.alloc(size, align, <u32 as Into<_>>::into(1u32));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/impls/alloc.rs:961:42
[INFO] [stdout]     |
[INFO] [stdout] 961 |                     rt.free(size, align, 1u32.into(), ptr);
[INFO] [stdout]     |                                          ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 961 -                     rt.free(size, align, 1u32.into(), ptr);
[INFO] [stdout] 961 +                     rt.free(size, align, 1u32, ptr);
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 961 -                     rt.free(size, align, 1u32.into(), ptr);
[INFO] [stdout] 961 +                     rt.free(size, align, <u32 as Into<_>>::into(1u32), ptr);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/impls/alloc.rs:978:49
[INFO] [stdout]     |
[INFO] [stdout] 978 |                     let ptr = rt.alloc(size, 8, 1u32.into());
[INFO] [stdout]     |                                                 ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 978 -                     let ptr = rt.alloc(size, 8, 1u32.into());
[INFO] [stdout] 978 +                     let ptr = rt.alloc(size, 8, 1u32);
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 978 -                     let ptr = rt.alloc(size, 8, 1u32.into());
[INFO] [stdout] 978 +                     let ptr = rt.alloc(size, 8, <u32 as Into<_>>::into(1u32));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/impls/alloc.rs:980:38
[INFO] [stdout]     |
[INFO] [stdout] 980 |                     rt.free(size, 8, 1u32.into(), ptr);
[INFO] [stdout]     |                                      ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 980 -                     rt.free(size, 8, 1u32.into(), ptr);
[INFO] [stdout] 980 +                     rt.free(size, 8, 1u32, ptr);
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 980 -                     rt.free(size, 8, 1u32.into(), ptr);
[INFO] [stdout] 980 +                     rt.free(size, 8, <u32 as Into<_>>::into(1u32), ptr);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/impls/alloc.rs:993:45
[INFO] [stdout]     |
[INFO] [stdout] 993 |                 let ptr = rt.alloc(size, 8, count.into());
[INFO] [stdout]     |                                             ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 993 -                 let ptr = rt.alloc(size, 8, count.into());
[INFO] [stdout] 993 +                 let ptr = rt.alloc(size, 8, count);
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 993 -                 let ptr = rt.alloc(size, 8, count.into());
[INFO] [stdout] 993 +                 let ptr = rt.alloc(size, 8, <u32 as Into<_>>::into(count));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/impls/alloc.rs:1001:34
[INFO] [stdout]      |
[INFO] [stdout] 1001 |                 rt.free(size, 8, count.into(), ptr);
[INFO] [stdout]      |                                  ^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1001 -                 rt.free(size, 8, count.into(), ptr);
[INFO] [stdout] 1001 +                 rt.free(size, 8, count, ptr);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1001 -                 rt.free(size, 8, count.into(), ptr);
[INFO] [stdout] 1001 +                 rt.free(size, 8, <u32 as Into<_>>::into(count), ptr);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]   --> src/impls/clone.rs:68:83
[INFO] [stdout]    |
[INFO] [stdout] 68 |                 let new_data = unsafe { rt_ref.alloc.alloc(limb_size, limb_align, num_limbs.into()) as *mut u32 };
[INFO] [stdout]    |                                                                                   ^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 68 -                 let new_data = unsafe { rt_ref.alloc.alloc(limb_size, limb_align, num_limbs.into()) as *mut u32 };
[INFO] [stdout] 68 +                 let new_data = unsafe { rt_ref.alloc.alloc(limb_size, limb_align, num_limbs) as *mut u32 };
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 68 -                 let new_data = unsafe { rt_ref.alloc.alloc(limb_size, limb_align, num_limbs.into()) as *mut u32 };
[INFO] [stdout] 68 +                 let new_data = unsafe { rt_ref.alloc.alloc(limb_size, limb_align, <u32 as Into<_>>::into(num_limbs)) as *mut u32 };
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/impls/clone.rs:713:65
[INFO] [stdout]     |
[INFO] [stdout] 713 |         rt_ref.alloc.alloc(rtdt::INDEX_SIZE, rtdt::INDEX_ALIGN, rank.into())
[INFO] [stdout]     |                                                                 ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 713 -         rt_ref.alloc.alloc(rtdt::INDEX_SIZE, rtdt::INDEX_ALIGN, rank.into())
[INFO] [stdout] 713 +         rt_ref.alloc.alloc(rtdt::INDEX_SIZE, rtdt::INDEX_ALIGN, rank)
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 713 -         rt_ref.alloc.alloc(rtdt::INDEX_SIZE, rtdt::INDEX_ALIGN, rank.into())
[INFO] [stdout] 713 +         rt_ref.alloc.alloc(rtdt::INDEX_SIZE, rtdt::INDEX_ALIGN, <u32 as Into<_>>::into(rank))
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/impls/clone.rs:722:65
[INFO] [stdout]     |
[INFO] [stdout] 722 |         rt_ref.alloc.alloc(rtdt::INDEX_SIZE, rtdt::INDEX_ALIGN, rank.into())
[INFO] [stdout]     |                                                                 ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 722 -         rt_ref.alloc.alloc(rtdt::INDEX_SIZE, rtdt::INDEX_ALIGN, rank.into())
[INFO] [stdout] 722 +         rt_ref.alloc.alloc(rtdt::INDEX_SIZE, rtdt::INDEX_ALIGN, rank)
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 722 -         rt_ref.alloc.alloc(rtdt::INDEX_SIZE, rtdt::INDEX_ALIGN, rank.into())
[INFO] [stdout] 722 +         rt_ref.alloc.alloc(rtdt::INDEX_SIZE, rtdt::INDEX_ALIGN, <u32 as Into<_>>::into(rank))
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/impls/clone.rs:727:68
[INFO] [stdout]     |
[INFO] [stdout] 727 |             rt_ref.alloc.free(rtdt::INDEX_SIZE, rtdt::INDEX_ALIGN, rank.into(), new_shape as *mut u8);
[INFO] [stdout]     |                                                                    ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 727 -             rt_ref.alloc.free(rtdt::INDEX_SIZE, rtdt::INDEX_ALIGN, rank.into(), new_shape as *mut u8);
[INFO] [stdout] 727 +             rt_ref.alloc.free(rtdt::INDEX_SIZE, rtdt::INDEX_ALIGN, rank, new_shape as *mut u8);
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 727 -             rt_ref.alloc.free(rtdt::INDEX_SIZE, rtdt::INDEX_ALIGN, rank.into(), new_shape as *mut u8);
[INFO] [stdout] 727 +             rt_ref.alloc.free(rtdt::INDEX_SIZE, rtdt::INDEX_ALIGN, <u32 as Into<_>>::into(rank), new_shape as *mut u8);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/impls/clone.rs:780:72
[INFO] [stdout]     |
[INFO] [stdout] 780 |                 rt_ref.alloc.free(rtdt::INDEX_SIZE, rtdt::INDEX_ALIGN, rank.into(), new_shape as *mut u8);
[INFO] [stdout]     |                                                                        ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 780 -                 rt_ref.alloc.free(rtdt::INDEX_SIZE, rtdt::INDEX_ALIGN, rank.into(), new_shape as *mut u8);
[INFO] [stdout] 780 +                 rt_ref.alloc.free(rtdt::INDEX_SIZE, rtdt::INDEX_ALIGN, rank, new_shape as *mut u8);
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 780 -                 rt_ref.alloc.free(rtdt::INDEX_SIZE, rtdt::INDEX_ALIGN, rank.into(), new_shape as *mut u8);
[INFO] [stdout] 780 +                 rt_ref.alloc.free(rtdt::INDEX_SIZE, rtdt::INDEX_ALIGN, <u32 as Into<_>>::into(rank), new_shape as *mut u8);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/impls/clone.rs:781:72
[INFO] [stdout]     |
[INFO] [stdout] 781 |                 rt_ref.alloc.free(rtdt::INDEX_SIZE, rtdt::INDEX_ALIGN, rank.into(), new_strides as *mut u8);
[INFO] [stdout]     |                                                                        ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 781 -                 rt_ref.alloc.free(rtdt::INDEX_SIZE, rtdt::INDEX_ALIGN, rank.into(), new_strides as *mut u8);
[INFO] [stdout] 781 +                 rt_ref.alloc.free(rtdt::INDEX_SIZE, rtdt::INDEX_ALIGN, rank, new_strides as *mut u8);
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 781 -                 rt_ref.alloc.free(rtdt::INDEX_SIZE, rtdt::INDEX_ALIGN, rank.into(), new_strides as *mut u8);
[INFO] [stdout] 781 +                 rt_ref.alloc.free(rtdt::INDEX_SIZE, rtdt::INDEX_ALIGN, <u32 as Into<_>>::into(rank), new_strides as *mut u8);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/impls/clone.rs:1015:52
[INFO] [stdout]      |
[INFO] [stdout] 1015 |                     let ptr = rt.alloc.alloc(4, 4, (limbs.len() as u32).into()) as *mut u32;
[INFO] [stdout]      |                                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1015 -                     let ptr = rt.alloc.alloc(4, 4, (limbs.len() as u32).into()) as *mut u32;
[INFO] [stdout] 1015 +                     let ptr = rt.alloc.alloc(4, 4, (limbs.len() as u32)) as *mut u32;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1015 -                     let ptr = rt.alloc.alloc(4, 4, (limbs.len() as u32).into()) as *mut u32;
[INFO] [stdout] 1015 +                     let ptr = rt.alloc.alloc(4, 4, <u32 as Into<_>>::into((limbs.len() as u32))) as *mut u32;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/impls/clone.rs:1061:41
[INFO] [stdout]      |
[INFO] [stdout] 1061 |                     rt.alloc.free(4, 4, (limbs.len() as u32).into(), value_out.data as *mut u8);
[INFO] [stdout]      |                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1061 -                     rt.alloc.free(4, 4, (limbs.len() as u32).into(), value_out.data as *mut u8);
[INFO] [stdout] 1061 +                     rt.alloc.free(4, 4, (limbs.len() as u32), value_out.data as *mut u8);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1061 -                     rt.alloc.free(4, 4, (limbs.len() as u32).into(), value_out.data as *mut u8);
[INFO] [stdout] 1061 +                     rt.alloc.free(4, 4, <u32 as Into<_>>::into((limbs.len() as u32)), value_out.data as *mut u8);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/impls/clone.rs:1068:41
[INFO] [stdout]      |
[INFO] [stdout] 1068 |                     rt.alloc.free(4, 4, (limbs.len() as u32).into(), limb_data as *mut u8);
[INFO] [stdout]      |                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1068 -                     rt.alloc.free(4, 4, (limbs.len() as u32).into(), limb_data as *mut u8);
[INFO] [stdout] 1068 +                     rt.alloc.free(4, 4, (limbs.len() as u32), limb_data as *mut u8);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1068 -                     rt.alloc.free(4, 4, (limbs.len() as u32).into(), limb_data as *mut u8);
[INFO] [stdout] 1068 +                     rt.alloc.free(4, 4, <u32 as Into<_>>::into((limbs.len() as u32)), limb_data as *mut u8);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/impls/clone.rs:1117:52
[INFO] [stdout]      |
[INFO] [stdout] 1117 |                     let ptr = rt.alloc.alloc(1, 1, (bytes.len() as u32).into());
[INFO] [stdout]      |                                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1117 -                     let ptr = rt.alloc.alloc(1, 1, (bytes.len() as u32).into());
[INFO] [stdout] 1117 +                     let ptr = rt.alloc.alloc(1, 1, (bytes.len() as u32));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1117 -                     let ptr = rt.alloc.alloc(1, 1, (bytes.len() as u32).into());
[INFO] [stdout] 1117 +                     let ptr = rt.alloc.alloc(1, 1, <u32 as Into<_>>::into((bytes.len() as u32)));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/impls/clone.rs:1162:41
[INFO] [stdout]      |
[INFO] [stdout] 1162 |                     rt.alloc.free(1, 1, (bytes.len() as u32).into(), value_out.data as *mut u8);
[INFO] [stdout]      |                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1162 -                     rt.alloc.free(1, 1, (bytes.len() as u32).into(), value_out.data as *mut u8);
[INFO] [stdout] 1162 +                     rt.alloc.free(1, 1, (bytes.len() as u32), value_out.data as *mut u8);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1162 -                     rt.alloc.free(1, 1, (bytes.len() as u32).into(), value_out.data as *mut u8);
[INFO] [stdout] 1162 +                     rt.alloc.free(1, 1, <u32 as Into<_>>::into((bytes.len() as u32)), value_out.data as *mut u8);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/impls/clone.rs:1169:41
[INFO] [stdout]      |
[INFO] [stdout] 1169 |                     rt.alloc.free(1, 1, (bytes.len() as u32).into(), str_data as *mut u8);
[INFO] [stdout]      |                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1169 -                     rt.alloc.free(1, 1, (bytes.len() as u32).into(), str_data as *mut u8);
[INFO] [stdout] 1169 +                     rt.alloc.free(1, 1, (bytes.len() as u32), str_data as *mut u8);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1169 -                     rt.alloc.free(1, 1, (bytes.len() as u32).into(), str_data as *mut u8);
[INFO] [stdout] 1169 +                     rt.alloc.free(1, 1, <u32 as Into<_>>::into((bytes.len() as u32)), str_data as *mut u8);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/impls/clone.rs:1302:52
[INFO] [stdout]      |
[INFO] [stdout] 1302 |                     let ptr = rt.alloc.alloc(4, 4, (elements.len() as u32).into()) as *mut u32;
[INFO] [stdout]      |                                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1302 -                     let ptr = rt.alloc.alloc(4, 4, (elements.len() as u32).into()) as *mut u32;
[INFO] [stdout] 1302 +                     let ptr = rt.alloc.alloc(4, 4, (elements.len() as u32)) as *mut u32;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1302 -                     let ptr = rt.alloc.alloc(4, 4, (elements.len() as u32).into()) as *mut u32;
[INFO] [stdout] 1302 +                     let ptr = rt.alloc.alloc(4, 4, <u32 as Into<_>>::into((elements.len() as u32))) as *mut u32;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/impls/clone.rs:1347:41
[INFO] [stdout]      |
[INFO] [stdout] 1347 |                     rt.alloc.free(4, 4, (elements.len() as u32).into(), value_out.data as *mut u8);
[INFO] [stdout]      |                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1347 -                     rt.alloc.free(4, 4, (elements.len() as u32).into(), value_out.data as *mut u8);
[INFO] [stdout] 1347 +                     rt.alloc.free(4, 4, (elements.len() as u32), value_out.data as *mut u8);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1347 -                     rt.alloc.free(4, 4, (elements.len() as u32).into(), value_out.data as *mut u8);
[INFO] [stdout] 1347 +                     rt.alloc.free(4, 4, <u32 as Into<_>>::into((elements.len() as u32)), value_out.data as *mut u8);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/impls/clone.rs:1354:41
[INFO] [stdout]      |
[INFO] [stdout] 1354 |                     rt.alloc.free(4, 4, (elements.len() as u32).into(), list_data as *mut u8);
[INFO] [stdout]      |                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1354 -                     rt.alloc.free(4, 4, (elements.len() as u32).into(), list_data as *mut u8);
[INFO] [stdout] 1354 +                     rt.alloc.free(4, 4, (elements.len() as u32), list_data as *mut u8);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1354 -                     rt.alloc.free(4, 4, (elements.len() as u32).into(), list_data as *mut u8);
[INFO] [stdout] 1354 +                     rt.alloc.free(4, 4, <u32 as Into<_>>::into((elements.len() as u32)), list_data as *mut u8);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/impls/clone.rs:1565:75
[INFO] [stdout]      |
[INFO] [stdout] 1565 |         let dst = rt_ref.alloc.alloc(rtdt::INDEX_SIZE, rtdt::INDEX_ALIGN, rank.into()) as *mut rtdt::Index;
[INFO] [stdout]      |                                                                           ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1565 -         let dst = rt_ref.alloc.alloc(rtdt::INDEX_SIZE, rtdt::INDEX_ALIGN, rank.into()) as *mut rtdt::Index;
[INFO] [stdout] 1565 +         let dst = rt_ref.alloc.alloc(rtdt::INDEX_SIZE, rtdt::INDEX_ALIGN, rank) as *mut rtdt::Index;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1565 -         let dst = rt_ref.alloc.alloc(rtdt::INDEX_SIZE, rtdt::INDEX_ALIGN, rank.into()) as *mut rtdt::Index;
[INFO] [stdout] 1565 +         let dst = rt_ref.alloc.alloc(rtdt::INDEX_SIZE, rtdt::INDEX_ALIGN, <u32 as Into<_>>::into(rank)) as *mut rtdt::Index;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/impls/string.rs:259:17
[INFO] [stdout]     |
[INFO] [stdout] 259 |                 (data.len() as u32).into(),
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 259 -                 (data.len() as u32).into(),
[INFO] [stdout] 259 +                 (data.len() as u32),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 259 -                 (data.len() as u32).into(),
[INFO] [stdout] 259 +                 <u32 as Into<_>>::into((data.len() as u32)),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/impls/tensor.rs:343:13
[INFO] [stdout]     |
[INFO] [stdout] 343 |             rank.into(),
[INFO] [stdout]     |             ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 343 -             rank.into(),
[INFO] [stdout] 343 +             rank,
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 343 -             rank.into(),
[INFO] [stdout] 343 +             <u32 as Into<_>>::into(rank),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/impls/tensor.rs:360:13
[INFO] [stdout]     |
[INFO] [stdout] 360 |             rank.into(),
[INFO] [stdout]     |             ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 360 -             rank.into(),
[INFO] [stdout] 360 +             rank,
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 360 -             rank.into(),
[INFO] [stdout] 360 +             <u32 as Into<_>>::into(rank),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/impls/tensor.rs:369:17
[INFO] [stdout]     |
[INFO] [stdout] 369 |                 rank.into(),
[INFO] [stdout]     |                 ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 369 -                 rank.into(),
[INFO] [stdout] 369 +                 rank,
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 369 -                 rank.into(),
[INFO] [stdout] 369 +                 <u32 as Into<_>>::into(rank),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/impls/tensor.rs:590:13
[INFO] [stdout]     |
[INFO] [stdout] 590 |             rank.into(),
[INFO] [stdout]     |             ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 590 -             rank.into(),
[INFO] [stdout] 590 +             rank,
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 590 -             rank.into(),
[INFO] [stdout] 590 +             <u32 as Into<_>>::into(rank),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/impls/tensor.rs:600:13
[INFO] [stdout]     |
[INFO] [stdout] 600 |             rank.into(),
[INFO] [stdout]     |             ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 600 -             rank.into(),
[INFO] [stdout] 600 +             rank,
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 600 -             rank.into(),
[INFO] [stdout] 600 +             <u32 as Into<_>>::into(rank),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/impls/tensor.rs:606:17
[INFO] [stdout]     |
[INFO] [stdout] 606 |                 rank.into(),
[INFO] [stdout]     |                 ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 606 -                 rank.into(),
[INFO] [stdout] 606 +                 rank,
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 606 -                 rank.into(),
[INFO] [stdout] 606 +                 <u32 as Into<_>>::into(rank),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/impls/tensor.rs:645:13
[INFO] [stdout]     |
[INFO] [stdout] 645 |             rank.into(),
[INFO] [stdout]     |             ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 645 -             rank.into(),
[INFO] [stdout] 645 +             rank,
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 645 -             rank.into(),
[INFO] [stdout] 645 +             <u32 as Into<_>>::into(rank),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/impls/tensor.rs:651:13
[INFO] [stdout]     |
[INFO] [stdout] 651 |             rank.into(),
[INFO] [stdout]     |             ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 651 -             rank.into(),
[INFO] [stdout] 651 +             rank,
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 651 -             rank.into(),
[INFO] [stdout] 651 +             <u32 as Into<_>>::into(rank),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/impls/tensor.rs:741:17
[INFO] [stdout]     |
[INFO] [stdout] 741 |                 rank.into(),
[INFO] [stdout]     |                 ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 741 -                 rank.into(),
[INFO] [stdout] 741 +                 rank,
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 741 -                 rank.into(),
[INFO] [stdout] 741 +                 <u32 as Into<_>>::into(rank),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/impls/tensor.rs:751:17
[INFO] [stdout]     |
[INFO] [stdout] 751 |                 rank.into(),
[INFO] [stdout]     |                 ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 751 -                 rank.into(),
[INFO] [stdout] 751 +                 rank,
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 751 -                 rank.into(),
[INFO] [stdout] 751 +                 <u32 as Into<_>>::into(rank),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/impls/tensor.rs:824:13
[INFO] [stdout]     |
[INFO] [stdout] 824 |             sub_rank.into(),
[INFO] [stdout]     |             ^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 824 -             sub_rank.into(),
[INFO] [stdout] 824 +             sub_rank,
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 824 -             sub_rank.into(),
[INFO] [stdout] 824 +             <u32 as Into<_>>::into(sub_rank),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/impls/tensor.rs:835:13
[INFO] [stdout]     |
[INFO] [stdout] 835 |             sub_rank.into(),
[INFO] [stdout]     |             ^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 835 -             sub_rank.into(),
[INFO] [stdout] 835 +             sub_rank,
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 835 -             sub_rank.into(),
[INFO] [stdout] 835 +             <u32 as Into<_>>::into(sub_rank),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/impls/tensor.rs:842:17
[INFO] [stdout]     |
[INFO] [stdout] 842 |                 sub_rank.into(),
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 842 -                 sub_rank.into(),
[INFO] [stdout] 842 +                 sub_rank,
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 842 -                 sub_rank.into(),
[INFO] [stdout] 842 +                 <u32 as Into<_>>::into(sub_rank),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/impls/tensor.rs:911:21
[INFO] [stdout]     |
[INFO] [stdout] 911 |                     sub_rank.into(),
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 911 -                     sub_rank.into(),
[INFO] [stdout] 911 +                     sub_rank,
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 911 -                     sub_rank.into(),
[INFO] [stdout] 911 +                     <u32 as Into<_>>::into(sub_rank),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/impls/tensor.rs:917:21
[INFO] [stdout]     |
[INFO] [stdout] 917 |                     sub_rank.into(),
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 917 -                     sub_rank.into(),
[INFO] [stdout] 917 +                     sub_rank,
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 917 -                     sub_rank.into(),
[INFO] [stdout] 917 +                     <u32 as Into<_>>::into(sub_rank),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/impls/tensor.rs:1024:13
[INFO] [stdout]      |
[INFO] [stdout] 1024 |             rank.into(),
[INFO] [stdout]      |             ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1024 -             rank.into(),
[INFO] [stdout] 1024 +             rank,
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1024 -             rank.into(),
[INFO] [stdout] 1024 +             <u32 as Into<_>>::into(rank),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/impls/tensor.rs:1041:13
[INFO] [stdout]      |
[INFO] [stdout] 1041 |             rank.into(),
[INFO] [stdout]      |             ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1041 -             rank.into(),
[INFO] [stdout] 1041 +             rank,
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1041 -             rank.into(),
[INFO] [stdout] 1041 +             <u32 as Into<_>>::into(rank),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/impls/tensor.rs:1049:17
[INFO] [stdout]      |
[INFO] [stdout] 1049 |                 rank.into(),
[INFO] [stdout]      |                 ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1049 -                 rank.into(),
[INFO] [stdout] 1049 +                 rank,
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1049 -                 rank.into(),
[INFO] [stdout] 1049 +                 <u32 as Into<_>>::into(rank),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/impls/tensor.rs:1080:13
[INFO] [stdout]      |
[INFO] [stdout] 1080 |             rank.into(),
[INFO] [stdout]      |             ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1080 -             rank.into(),
[INFO] [stdout] 1080 +             rank,
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1080 -             rank.into(),
[INFO] [stdout] 1080 +             <u32 as Into<_>>::into(rank),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/impls/tensor.rs:1086:13
[INFO] [stdout]      |
[INFO] [stdout] 1086 |             rank.into(),
[INFO] [stdout]      |             ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1086 -             rank.into(),
[INFO] [stdout] 1086 +             rank,
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1086 -             rank.into(),
[INFO] [stdout] 1086 +             <u32 as Into<_>>::into(rank),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/impls/tensor.rs:1277:64
[INFO] [stdout]      |
[INFO] [stdout] 1277 |         rt_ref.alloc.free(rtdt::INDEX_SIZE, rtdt::INDEX_ALIGN, rank.into(), strides_ptr as *mut u8);
[INFO] [stdout]      |                                                                ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1277 -         rt_ref.alloc.free(rtdt::INDEX_SIZE, rtdt::INDEX_ALIGN, rank.into(), strides_ptr as *mut u8);
[INFO] [stdout] 1277 +         rt_ref.alloc.free(rtdt::INDEX_SIZE, rtdt::INDEX_ALIGN, rank, strides_ptr as *mut u8);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1277 -         rt_ref.alloc.free(rtdt::INDEX_SIZE, rtdt::INDEX_ALIGN, rank.into(), strides_ptr as *mut u8);
[INFO] [stdout] 1277 +         rt_ref.alloc.free(rtdt::INDEX_SIZE, rtdt::INDEX_ALIGN, <u32 as Into<_>>::into(rank), strides_ptr as *mut u8);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]     --> src/impls/tensor.rs:1280:64
[INFO] [stdout]      |
[INFO] [stdout] 1280 |         rt_ref.alloc.free(rtdt::INDEX_SIZE, rtdt::INDEX_ALIGN, rank.into(), shape_ptr as *mut u8);
[INFO] [stdout]      |                                                                ^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1280 -         rt_ref.alloc.free(rtdt::INDEX_SIZE, rtdt::INDEX_ALIGN, rank.into(), shape_ptr as *mut u8);
[INFO] [stdout] 1280 +         rt_ref.alloc.free(rtdt::INDEX_SIZE, rtdt::INDEX_ALIGN, rank, shape_ptr as *mut u8);
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1280 -         rt_ref.alloc.free(rtdt::INDEX_SIZE, rtdt::INDEX_ALIGN, rank.into(), shape_ptr as *mut u8);
[INFO] [stdout] 1280 +         rt_ref.alloc.free(rtdt::INDEX_SIZE, rtdt::INDEX_ALIGN, <u32 as Into<_>>::into(rank), shape_ptr as *mut u8);
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/impls/destroy.rs:137:76
[INFO] [stdout]     |
[INFO] [stdout] 137 |                     rt_ref.alloc.free(rtdt::INDEX_SIZE, rtdt::INDEX_ALIGN, rank.into(), tensor.shape as *mut u8);
[INFO] [stdout]     |                                                                            ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 137 -                     rt_ref.alloc.free(rtdt::INDEX_SIZE, rtdt::INDEX_ALIGN, rank.into(), tensor.shape as *mut u8);
[INFO] [stdout] 137 +                     rt_ref.alloc.free(rtdt::INDEX_SIZE, rtdt::INDEX_ALIGN, rank, tensor.shape as *mut u8);
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 137 -                     rt_ref.alloc.free(rtdt::INDEX_SIZE, rtdt::INDEX_ALIGN, rank.into(), tensor.shape as *mut u8);
[INFO] [stdout] 137 +                     rt_ref.alloc.free(rtdt::INDEX_SIZE, rtdt::INDEX_ALIGN, <u32 as Into<_>>::into(rank), tensor.shape as *mut u8);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/impls/destroy.rs:142:76
[INFO] [stdout]     |
[INFO] [stdout] 142 |                     rt_ref.alloc.free(rtdt::INDEX_SIZE, rtdt::INDEX_ALIGN, rank.into(), tensor.strides as *mut u8);
[INFO] [stdout]     |                                                                            ^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 142 -                     rt_ref.alloc.free(rtdt::INDEX_SIZE, rtdt::INDEX_ALIGN, rank.into(), tensor.strides as *mut u8);
[INFO] [stdout] 142 +                     rt_ref.alloc.free(rtdt::INDEX_SIZE, rtdt::INDEX_ALIGN, rank, tensor.strides as *mut u8);
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 142 -                     rt_ref.alloc.free(rtdt::INDEX_SIZE, rtdt::INDEX_ALIGN, rank.into(), tensor.strides as *mut u8);
[INFO] [stdout] 142 +                     rt_ref.alloc.free(rtdt::INDEX_SIZE, rtdt::INDEX_ALIGN, <u32 as Into<_>>::into(rank), tensor.strides as *mut u8);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]   --> src/impls/int_math.rs:51:47
[INFO] [stdout]    |
[INFO] [stdout] 51 |         let result_ptr = rt.alloc.alloc(4, 4, (result_len as u32).into()) as *mut u32;
[INFO] [stdout]    |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 51 -         let result_ptr = rt.alloc.alloc(4, 4, (result_len as u32).into()) as *mut u32;
[INFO] [stdout] 51 +         let result_ptr = rt.alloc.alloc(4, 4, (result_len as u32)) as *mut u32;
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 51 -         let result_ptr = rt.alloc.alloc(4, 4, (result_len as u32).into()) as *mut u32;
[INFO] [stdout] 51 +         let result_ptr = rt.alloc.alloc(4, 4, <u32 as Into<_>>::into((result_len as u32))) as *mut u32;
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]   --> src/impls/int_math.rs:94:47
[INFO] [stdout]    |
[INFO] [stdout] 94 |         let result_ptr = rt.alloc.alloc(4, 4, (result_len as u32).into()) as *mut u32;
[INFO] [stdout]    |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 94 -         let result_ptr = rt.alloc.alloc(4, 4, (result_len as u32).into()) as *mut u32;
[INFO] [stdout] 94 +         let result_ptr = rt.alloc.alloc(4, 4, (result_len as u32)) as *mut u32;
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 94 -         let result_ptr = rt.alloc.alloc(4, 4, (result_len as u32).into()) as *mut u32;
[INFO] [stdout] 94 +         let result_ptr = rt.alloc.alloc(4, 4, <u32 as Into<_>>::into((result_len as u32))) as *mut u32;
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/impls/int_math.rs:201:52
[INFO] [stdout]     |
[INFO] [stdout] 201 |         let neg_b_limbs_ptr = rt.alloc.alloc(4, 4, (b_abs_size as u32).into()) as *mut u32;
[INFO] [stdout]     |                                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 201 -         let neg_b_limbs_ptr = rt.alloc.alloc(4, 4, (b_abs_size as u32).into()) as *mut u32;
[INFO] [stdout] 201 +         let neg_b_limbs_ptr = rt.alloc.alloc(4, 4, (b_abs_size as u32)) as *mut u32;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 201 -         let neg_b_limbs_ptr = rt.alloc.alloc(4, 4, (b_abs_size as u32).into()) as *mut u32;
[INFO] [stdout] 201 +         let neg_b_limbs_ptr = rt.alloc.alloc(4, 4, <u32 as Into<_>>::into((b_abs_size as u32))) as *mut u32;
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/impls/int_math.rs:217:29
[INFO] [stdout]     |
[INFO] [stdout] 217 |         rt.alloc.free(4, 4, (b_abs_size as u32).into(), neg_b_limbs_ptr as *mut u8);
[INFO] [stdout]     |                             ^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 217 -         rt.alloc.free(4, 4, (b_abs_size as u32).into(), neg_b_limbs_ptr as *mut u8);
[INFO] [stdout] 217 +         rt.alloc.free(4, 4, (b_abs_size as u32), neg_b_limbs_ptr as *mut u8);
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 217 -         rt.alloc.free(4, 4, (b_abs_size as u32).into(), neg_b_limbs_ptr as *mut u8);
[INFO] [stdout] 217 +         rt.alloc.free(4, 4, <u32 as Into<_>>::into((b_abs_size as u32)), neg_b_limbs_ptr as *mut u8);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/impls/int_math.rs:277:47
[INFO] [stdout]     |
[INFO] [stdout] 277 |         let result_ptr = rt.alloc.alloc(4, 4, (result_len as u32).into()) as *mut u32;
[INFO] [stdout]     |                                               ^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 277 -         let result_ptr = rt.alloc.alloc(4, 4, (result_len as u32).into()) as *mut u32;
[INFO] [stdout] 277 +         let result_ptr = rt.alloc.alloc(4, 4, (result_len as u32)) as *mut u32;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 277 -         let result_ptr = rt.alloc.alloc(4, 4, (result_len as u32).into()) as *mut u32;
[INFO] [stdout] 277 +         let result_ptr = rt.alloc.alloc(4, 4, <u32 as Into<_>>::into((result_len as u32))) as *mut u32;
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/impls/int_math.rs:319:46
[INFO] [stdout]     |
[INFO] [stdout] 319 |         let limbs_ptr = rt.alloc.alloc(4, 4, (abs_size as u32).into()) as *mut u32;
[INFO] [stdout]     |                                              ^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 319 -         let limbs_ptr = rt.alloc.alloc(4, 4, (abs_size as u32).into()) as *mut u32;
[INFO] [stdout] 319 +         let limbs_ptr = rt.alloc.alloc(4, 4, (abs_size as u32)) as *mut u32;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 319 -         let limbs_ptr = rt.alloc.alloc(4, 4, (abs_size as u32).into()) as *mut u32;
[INFO] [stdout] 319 +         let limbs_ptr = rt.alloc.alloc(4, 4, <u32 as Into<_>>::into((abs_size as u32))) as *mut u32;
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/impls/int_math.rs:380:46
[INFO] [stdout]     |
[INFO] [stdout] 380 |             let q_ptr = rt.alloc.alloc(4, 4, (q_len as u32).into()) as *mut u32;
[INFO] [stdout]     |                                              ^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 380 -             let q_ptr = rt.alloc.alloc(4, 4, (q_len as u32).into()) as *mut u32;
[INFO] [stdout] 380 +             let q_ptr = rt.alloc.alloc(4, 4, (q_len as u32)) as *mut u32;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 380 -             let q_ptr = rt.alloc.alloc(4, 4, (q_len as u32).into()) as *mut u32;
[INFO] [stdout] 380 +             let q_ptr = rt.alloc.alloc(4, 4, <u32 as Into<_>>::into((q_len as u32))) as *mut u32;
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `u32`
[INFO] [stdout]    --> src/impls/int_math.rs:488:46
[INFO] [stdout]     |
[INFO] [stdout] 488 |             let q_ptr = rt.alloc.alloc(4, 4, (q_len as u32).into()) as *mut u32;
[INFO] [stdout]     |                                              ^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 488 -             let q_ptr = rt.alloc.alloc(4, 4, (q_len as u32).into()) as *mut u32;
[INFO] [stdout] 488 +             let q_ptr = rt.alloc.alloc(4, 4, (q_len as u32)) as *mut u32;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 488 -             let q_ptr = rt.alloc.alloc(4, 4, (q_len as u32).into()) as *mut u32;
[INFO] [stdout] 488 +             let q_ptr = rt.alloc.alloc(4, 4, <u32 as Into<_>>::into((q_len as u32))) as *mut u32;
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `datalove-rt` (lib test) due to 63 previous errors; 1 warning emitted
[INFO] running `Command { std: "docker" "inspect" "b4c9c20751cb535381f6d7a8070b6e5532a72e356dbd70186791a457cc529da7", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "b4c9c20751cb535381f6d7a8070b6e5532a72e356dbd70186791a457cc529da7", kill_on_drop: false }`
[INFO] [stdout] b4c9c20751cb535381f6d7a8070b6e5532a72e356dbd70186791a457cc529da7
