[INFO] fetching crate cubecl-std 0.11.0...
[INFO] checking cubecl-std-0.11.0 against a5689b034ad287112f709693384a37f1377eb9cc for pr-129249-3
[INFO] extracting crate cubecl-std 0.11.0 into /workspace/builds/worker-5-tc2/source
[INFO] started tweaking crates.io crate cubecl-std 0.11.0
[INFO] finished tweaking crates.io crate cubecl-std 0.11.0
[INFO] tweaked toml for crates.io crate cubecl-std 0.11.0 written to /workspace/builds/worker-5-tc2/source/Cargo.toml
[INFO] validating manifest of crates.io crate cubecl-std 0.11.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 cubecl-std 0.11.0 already has a lockfile, it will not be regenerated
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "fetch" "--manifest-path" "Cargo.toml", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-5-tc2/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-5-tc2/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/cargo-home:/opt/rustwide/cargo-home:ro,Z" "-v" "/var/lib/crater-agent-workspace/rustup-home:/opt/rustwide/rustup-home:ro,Z" "-m" "1610612736" "--network" "none" "ghcr.io/rust-lang/crates-build-env/linux@sha256:77db811e55d90add9212f6832c23229e3de5f1c1f9905e8cb07319ea15df73ac" "sleep" "infinity", kill_on_drop: false }`
[INFO] [stdout] 29c48db805e442ee715d83640f532063472b5a6f5a78c013b623ad030e6947d8
[INFO] running `Command { std: "docker" "start" "29c48db805e442ee715d83640f532063472b5a6f5a78c013b623ad030e6947d8", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "29c48db805e442ee715d83640f532063472b5a6f5a78c013b623ad030e6947d8", 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" "29c48db805e442ee715d83640f532063472b5a6f5a78c013b623ad030e6947d8" "/opt/rustwide/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "29c48db805e442ee715d83640f532063472b5a6f5a78c013b623ad030e6947d8", 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" "29c48db805e442ee715d83640f532063472b5a6f5a78c013b623ad030e6947d8" "/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.107
[INFO] [stderr]    Compiling quote v1.0.47
[INFO] [stderr]    Compiling serde_core v1.0.229
[INFO] [stderr]    Compiling serde v1.0.229
[INFO] [stderr]     Checking memchr v2.8.3
[INFO] [stderr]    Compiling const_fn v0.4.12
[INFO] [stderr]    Compiling cfg_aliases v0.2.2
[INFO] [stderr]    Compiling unicode-segmentation v1.13.3
[INFO] [stderr]    Compiling zerocopy v0.8.56
[INFO] [stderr]    Compiling crossbeam-utils v0.8.22
[INFO] [stderr]     Checking foldhash v0.2.0
[INFO] [stderr]    Compiling zmij v1.0.23
[INFO] [stderr]    Compiling recasting v0.2.3
[INFO] [stderr]     Checking event-listener v5.4.2
[INFO] [stderr]    Compiling serde_json v1.0.151
[INFO] [stderr]     Checking cpufeatures v0.3.1
[INFO] [stderr]    Compiling linkme-impl v0.3.37
[INFO] [stderr]     Checking log v0.4.34
[INFO] [stderr]    Compiling rustc-hash v2.1.3
[INFO] [stderr]     Checking unicode-ident v1.0.24
[INFO] [stderr]     Checking ciborium-io v0.2.2
[INFO] [stderr]     Checking futures-core v0.3.34
[INFO] [stderr]    Compiling triple_arena v0.15.1
[INFO] [stderr]     Checking event-listener-strategy v0.5.4
[INFO] [stderr]     Checking chacha20 v0.10.2
[INFO] [stderr]    Compiling slotmap v1.1.1
[INFO] [stderr]    Compiling cubecl-environment v0.11.0
[INFO] [stderr]     Checking spin v0.12.3
[INFO] [stderr]    Compiling thiserror v2.0.20
[INFO] [stderr]    Compiling rustc_apfloat v0.2.3+llvm-462a31f5a5ab
[INFO] [stderr]    Compiling bytes v1.12.1
[INFO] [stderr]     Checking concurrent-queue v2.5.0
[INFO] [stderr]    Compiling linkme v0.3.37
[INFO] [stderr]     Checking async-channel v2.5.0
[INFO] [stderr]     Checking rand v0.10.2
[INFO] [stderr]    Compiling convert_case v0.10.0
[INFO] [stderr]    Compiling convert_case v0.11.0
[INFO] [stderr]    Compiling indexmap v2.14.1
[INFO] [stderr]    Compiling cubecl-common v0.11.0
[INFO] [stderr]    Compiling awint_internals v0.19.0
[INFO] [stderr]     Checking aho-corasick v1.1.5
[INFO] [stderr]    Compiling awint_core v0.19.0
[INFO] [stderr]     Checking nom v8.0.0
[INFO] [stderr]     Checking embassy-futures v0.1.2
[INFO] [stderr]     Checking web-time v1.1.0
[INFO] [stderr]    Compiling syn v3.0.4
[INFO] [stderr]    Compiling syn v2.0.119
[INFO] [stderr]     Checking oneshot v0.2.1
[INFO] [stderr]    Compiling inflections v1.1.1
[INFO] [stderr]    Compiling portable-atomic v1.15.0
[INFO] [stderr]    Compiling mutants v0.0.3
[INFO] [stderr]    Compiling combine v4.6.8
[INFO] [stderr]     Checking awint_ext v0.19.0
[INFO] [stderr]    Compiling unsynn v0.3.0
[INFO] [stderr]     Checking float4 v0.2.0
[INFO] [stderr]     Checking downcast-rs v2.0.2
[INFO] [stderr]     Checking once_vec v0.4.0
[INFO] [stderr]     Checking either v1.18.0
[INFO] [stderr]     Checking xxhash-rust v0.8.18
[INFO] [stderr]    Compiling libc v0.2.189
[INFO] [stderr]    Compiling prettyplease v0.3.0
[INFO] [stderr]     Checking itertools v0.15.0
[INFO] [stderr]    Compiling cubecl-monitoring v0.11.0
[INFO] [stderr]     Checking num-integer v0.1.47
[INFO] [stderr]     Checking float-ord v0.3.2
[INFO] [stderr]    Compiling awint_macro_internals v0.19.0
[INFO] [stderr]    Compiling cubecl-runtime v0.11.0
[INFO] [stderr]    Compiling cubecl-macros v0.11.0
[INFO] [stderr]     Checking futures-task v0.3.34
[INFO] [stderr]     Checking slab v0.4.12
[INFO] [stderr]     Checking sharded-slab v0.1.7
[INFO] [stderr]     Checking futures-util v0.3.34
[INFO] [stderr]     Checking regex-automata v0.4.18
[INFO] [stderr]     Checking tracing v0.1.44
[INFO] [stderr]     Checking thread_local v1.1.10
[INFO] [stderr]    Compiling variadics_please v2.0.0
[INFO] [stderr]    Compiling awint_macros v0.19.0
[INFO] [stderr]     Checking awint v0.19.0
[INFO] [stderr]     Checking buildid v1.0.5
[INFO] [stderr]     Checking hashbrown v0.17.1
[INFO] [stderr]     Checking serde_bytes v0.11.19
[INFO] [stderr]     Checking bitflags v2.13.1
[INFO] [stderr]     Checking regex v1.13.1
[INFO] [stderr]     Checking matchers v0.2.0
[INFO] [stderr]     Checking tracing-subscriber v0.3.23
[INFO] [stderr]    Compiling test-log-core v0.2.21
[INFO] [stderr]     Checking tynm v0.2.0
[INFO] [stderr]    Compiling darling_core v0.24.1
[INFO] [stderr]    Compiling zerocopy-derive v0.8.56
[INFO] [stderr]    Compiling derive_more-impl v2.1.1
[INFO] [stderr]    Compiling derive-new v0.7.0
[INFO] [stderr]    Compiling test-log-macros v0.2.21
[INFO] [stderr]     Checking test-log v0.2.21
[INFO] [stderr]    Compiling serde_derive v1.0.229
[INFO] [stderr]    Compiling bytemuck_derive v1.12.0
[INFO] [stderr]    Compiling thiserror-impl v2.0.20
[INFO] [stderr]     Checking bytemuck v1.25.2
[INFO] [stderr]     Checking safe_arch v1.2.0
[INFO] [stderr]     Checking num-complex v0.4.6
[INFO] [stderr]    Compiling pliron-derive v0.19.0
[INFO] [stderr]    Compiling darling_macro v0.24.1
[INFO] [stderr]    Compiling darling v0.24.1
[INFO] [stderr]    Compiling cubecl-macros-internal v0.11.0
[INFO] [stderr]     Checking wide v1.7.0
[INFO] [stderr]     Checking smallvec v1.16.0
[INFO] [stderr]     Checking internment v0.8.6
[INFO] [stderr]     Checking cubecl-zspace v0.11.0
[INFO] [stderr]     Checking derive_more v2.1.1
[INFO] [stderr]     Checking half v2.7.1
[INFO] [stderr]     Checking ciborium-ll v0.2.2
[INFO] [stderr]     Checking float8 v0.7.0
[INFO] [stderr]     Checking ciborium v0.2.2
[INFO] [stderr]     Checking hi_sparse_bitset v0.9.0
[INFO] [stderr]     Checking pliron v0.19.0
[INFO] [stderr]     Checking cubecl-ir v0.11.0
[INFO] [stderr]     Checking cubecl-core v0.11.0
[INFO] [stderr]     Checking cubecl-std v0.11.0 (/opt/rustwide/workdir)
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<I>`
[INFO] [stdout]   --> src/fast_math.rs:44:23
[INFO] [stdout]    |
[INFO] [stdout] 44 |     pub fn div(&self, dividend: I) -> I {
[INFO] [stdout]    |                       ^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: `#[deny(self_type_conversion)]` on by default
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 44 |     pub fn div(&self, <cubecl_core::frontend::NativeExpand<I> as Into<_>>::into(dividend): I) -> I {
[INFO] [stdout]    |                       ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<I>`
[INFO] [stdout]   --> src/fast_math.rs:58:26
[INFO] [stdout]    |
[INFO] [stdout] 58 |     pub fn modulo(&self, dividend: I) -> I {
[INFO] [stdout]    |                          ^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 58 |     pub fn modulo(&self, <cubecl_core::frontend::NativeExpand<I> as Into<_>>::into(dividend): I) -> I {
[INFO] [stdout]    |                          ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<I>`
[INFO] [stdout]   --> src/fast_math.rs:66:27
[INFO] [stdout]    |
[INFO] [stdout] 66 |     pub fn div_mod(&self, dividend: I) -> (I, I) {
[INFO] [stdout]    |                           ^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 66 |     pub fn div_mod(&self, <cubecl_core::frontend::NativeExpand<I> as Into<_>>::into(dividend): I) -> (I, I) {
[INFO] [stdout]    |                           ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]   --> src/reinterpret_slice.rs:72:25
[INFO] [stdout]    |
[INFO] [stdout] 72 |                     for j in 0..self.vector_size {
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 72 |                     for <usize as Into<_>>::into(j) in 0..self.vector_size {
[INFO] [stdout]    |                         +++++++++++++++++++++++++ +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<<S as cubecl_core::frontend::CubePrimitive>::Scalar>`
[INFO] [stdout]   --> src/reinterpret_slice.rs:73:76
[INFO] [stdout]    |
[INFO] [stdout] 73 |                         vector.insert(comptime!(k * self.vector_size + j), elem.extract(j));
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 73 |                         vector.insert(comptime!(k * self.vector_size + j), <cubecl_core::frontend::NativeExpand<<S as cubecl_core::frontend::CubePrimitive>::Scalar> as Into<_>>::into(elem.extract(j)));
[INFO] [stdout]    |                                                                            ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++               +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `NativeExpand<Vector<<S as CubePrimitive>::Scalar, DynamicSize<__N2>>>`
[INFO] [stdout]   --> src/reinterpret_slice.rs:67:25
[INFO] [stdout]    |
[INFO] [stdout] 67 |                 let mut vector = Vector::<S::Scalar, N2>::empty();
[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: the full name for the type has been written to '/opt/rustwide/target/debug/build/cubecl-std/951faf6648960f40/out/cubecl_std-951faf6648960f40.long-type-6813550293590913956.txt'
[INFO] [stdout]    = note: consider using `--verbose` to print the full type name to the console
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 67 |                 let mut <cubecl_core::frontend::NativeExpand<cubecl_core::frontend::Vector<<S as cubecl_core::frontend::CubePrimitive>::Scalar, DynamicSize<ReinterpretSliceExpand<'a, S, T>::__expand_read_method::__N2>>> as Into<_>>::into(vector) = Vector::<S::Scalar, N2>::empty();
[INFO] [stdout]    |                         ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]    --> src/reinterpret_slice.rs:148:25
[INFO] [stdout]     |
[INFO] [stdout] 148 |                     for j in 0..self.vector_size {
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 148 |                     for <usize as Into<_>>::into(j) in 0..self.vector_size {
[INFO] [stdout]     |                         +++++++++++++++++++++++++ +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<<S as cubecl_core::frontend::CubePrimitive>::Scalar>`
[INFO] [stdout]    --> src/reinterpret_slice.rs:149:76
[INFO] [stdout]     |
[INFO] [stdout] 149 |                         vector.insert(comptime!(k * self.vector_size + j), elem.extract(j));
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 149 |                         vector.insert(comptime!(k * self.vector_size + j), <cubecl_core::frontend::NativeExpand<<S as cubecl_core::frontend::CubePrimitive>::Scalar> as Into<_>>::into(elem.extract(j)));
[INFO] [stdout]     |                                                                            ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++               +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `NativeExpand<Vector<<S as CubePrimitive>::Scalar, DynamicSize<__N2>>>`
[INFO] [stdout]    --> src/reinterpret_slice.rs:143:25
[INFO] [stdout]     |
[INFO] [stdout] 143 |                 let mut vector = Vector::<S::Scalar, N2>::empty();
[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: the full name for the type has been written to '/opt/rustwide/target/debug/build/cubecl-std/951faf6648960f40/out/cubecl_std-951faf6648960f40.long-type-17693361451730304223.txt'
[INFO] [stdout]     = note: consider using `--verbose` to print the full type name to the console
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 143 |                 let mut <cubecl_core::frontend::NativeExpand<cubecl_core::frontend::Vector<<S as cubecl_core::frontend::CubePrimitive>::Scalar, DynamicSize<ReinterpretSliceMutExpand<'a, S, T>::__expand_read_method::__N2>>> as Into<_>>::into(vector) = Vector::<S::Scalar, N2>::empty();
[INFO] [stdout]     |                         +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<T>`
[INFO] [stdout]    --> src/reinterpret_slice.rs:158:43
[INFO] [stdout]     |
[INFO] [stdout] 158 |     pub fn write(&mut self, index: usize, value: T) {
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 158 |     pub fn write(&mut self, index: usize, <cubecl_core::frontend::NativeExpand<T> as Into<_>>::into(value): T) {
[INFO] [stdout]     |                                           ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]    --> src/reinterpret_slice.rs:173:25
[INFO] [stdout]     |
[INFO] [stdout] 173 |                     for j in 0..vector_size {
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 173 |                     for <usize as Into<_>>::into(j) in 0..vector_size {
[INFO] [stdout]     |                         +++++++++++++++++++++++++ +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<<S as cubecl_core::frontend::CubePrimitive>::Scalar>`
[INFO] [stdout]    --> src/reinterpret_slice.rs:174:42
[INFO] [stdout]     |
[INFO] [stdout] 174 |                         vector.insert(j, reinterpreted.extract(k * vector_size + j));
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 174 |                         vector.insert(j, <cubecl_core::frontend::NativeExpand<<S as cubecl_core::frontend::CubePrimitive>::Scalar> as Into<_>>::into(reinterpreted.extract(k * vector_size + j)));
[INFO] [stdout]     |                                          ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++                                          +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `NativeExpand<Vector<<S as CubePrimitive>::Scalar, DynamicSize<__N1>>>`
[INFO] [stdout]    --> src/reinterpret_slice.rs:162:13
[INFO] [stdout]     |
[INFO] [stdout] 162 |         let reinterpreted = Vector::<S::Scalar, N1>::reinterpret(value);
[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: the full name for the type has been written to '/opt/rustwide/target/debug/build/cubecl-std/951faf6648960f40/out/cubecl_std-951faf6648960f40.long-type-9490949361823162567.txt'
[INFO] [stdout]     = note: consider using `--verbose` to print the full type name to the console
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 162 |         let <cubecl_core::frontend::NativeExpand<cubecl_core::frontend::Vector<<S as cubecl_core::frontend::CubePrimitive>::Scalar, DynamicSize<ReinterpretSliceMutExpand<'a, S, T>::__expand_write_method::__N1>>> as Into<_>>::into(reinterpreted) = Vector::<S::Scalar, N1>::reinterpret(value);
[INFO] [stdout]     |             ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++             +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<u32>`
[INFO] [stdout]   --> src/swizzle.rs:88:17
[INFO] [stdout]    |
[INFO] [stdout] 88 |             let offset_masked = offset_bytes & self.yyy_mask;
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 88 |             let <cubecl_core::frontend::NativeExpand<u32> as Into<_>>::into(offset_masked) = offset_bytes & self.yyy_mask;
[INFO] [stdout]    |                 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++             +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<cubecl_core::frontend::Vector<Q, NQ>>`
[INFO] [stdout]   --> src/quant/dequantize.rs:17:5
[INFO] [stdout]    |
[INFO] [stdout] 17 |     value: Vector<Q, NQ>,
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 17 |     <cubecl_core::frontend::NativeExpand<cubecl_core::frontend::Vector<Q, NQ>> as Into<_>>::into(value): Vector<Q, NQ>,
[INFO] [stdout]    |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<cubecl_core::frontend::Vector<u32, NQ>>`
[INFO] [stdout]   --> src/quant/dequantize.rs:27:42
[INFO] [stdout]    |
[INFO] [stdout] 27 |             unpack_cast_u32::<F, NQ, NF>(Vector::cast_from(value), table.clone(), scheme)
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 27 |             unpack_cast_u32::<F, NQ, NF>(<cubecl_core::frontend::NativeExpand<cubecl_core::frontend::Vector<u32, NQ>> as Into<_>>::into(Vector::cast_from(value)), table.clone(), scheme)
[INFO] [stdout]    |                                          +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++                        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::ComptimeOptionExpand<Box<[f32]>>`
[INFO] [stdout]   --> src/quant/dequantize.rs:27:68
[INFO] [stdout]    |
[INFO] [stdout] 27 |             unpack_cast_u32::<F, NQ, NF>(Vector::cast_from(value), table.clone(), scheme)
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 27 |             unpack_cast_u32::<F, NQ, NF>(Vector::cast_from(value), <cubecl_core::frontend::ComptimeOptionExpand<Box<[f32]>> as Into<_>>::into(table.clone()), scheme)
[INFO] [stdout]    |                                                                    +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++             +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::quant::scheme::QuantScheme`
[INFO] [stdout]   --> src/quant/dequantize.rs:20:17
[INFO] [stdout]    |
[INFO] [stdout] 20 |     #[comptime] scheme: QuantScheme,
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 20 |     #[comptime] <cubecl_core::quant::scheme::QuantScheme as Into<_>>::into(scheme): QuantScheme,
[INFO] [stdout]    |                 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<S>`
[INFO] [stdout]   --> src/quant/dequantize.rs:18:5
[INFO] [stdout]    |
[INFO] [stdout] 18 |     scale: S,
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 18 |     <cubecl_core::frontend::NativeExpand<S> as Into<_>>::into(scale): S,
[INFO] [stdout]    |     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<cubecl_core::frontend::Vector<Q, NQ>>`
[INFO] [stdout]   --> src/quant/dequantize.rs:47:5
[INFO] [stdout]    |
[INFO] [stdout] 47 |     value: Vector<Q, NQ>,
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 47 |     <cubecl_core::frontend::NativeExpand<cubecl_core::frontend::Vector<Q, NQ>> as Into<_>>::into(value): Vector<Q, NQ>,
[INFO] [stdout]    |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<f32>`
[INFO] [stdout]   --> src/quant/dequantize.rs:48:5
[INFO] [stdout]    |
[INFO] [stdout] 48 |     scale: f32,
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 48 |     <cubecl_core::frontend::NativeExpand<f32> as Into<_>>::into(scale): f32,
[INFO] [stdout]    |     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::ComptimeOptionExpand<Box<[f32]>>`
[INFO] [stdout]   --> src/quant/dequantize.rs:49:5
[INFO] [stdout]    |
[INFO] [stdout] 49 |     table: ComptimeOption<Box<[f32]>>,
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 49 |     <cubecl_core::frontend::ComptimeOptionExpand<Box<[f32]>> as Into<_>>::into(table): ComptimeOption<Box<[f32]>>,
[INFO] [stdout]    |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::quant::scheme::QuantScheme`
[INFO] [stdout]   --> src/quant/dequantize.rs:50:17
[INFO] [stdout]    |
[INFO] [stdout] 50 |     #[comptime] scheme: QuantScheme,
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 50 |     #[comptime] <cubecl_core::quant::scheme::QuantScheme as Into<_>>::into(scheme): QuantScheme,
[INFO] [stdout]    |                 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<cubecl_core::frontend::Vector<f32, NF>>`
[INFO] [stdout]   --> src/quant/dequantize.rs:52:32
[INFO] [stdout]    |
[INFO] [stdout] 52 |       Vector::<F, NF>::cast_from(dequantize_aligned::<Q, f32, f32, NQ, NF>(
[INFO] [stdout]    |  ________________________________^
[INFO] [stdout] 53 | |         value, scale, table, scheme,
[INFO] [stdout] 54 | |     ))
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 52 ~     Vector::<F, NF>::cast_from(<cubecl_core::frontend::NativeExpand<cubecl_core::frontend::Vector<f32, NF>> as Into<_>>::into(dequantize_aligned::<Q, f32, f32, NQ, NF>(
[INFO] [stdout] 53 |         value, scale, table, scheme,
[INFO] [stdout] 54 ~     )))
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<S>`
[INFO] [stdout]   --> src/quant/dequantize.rs:63:67
[INFO] [stdout]    |
[INFO] [stdout] 63 | pub fn multiply_global_scale<S: CubePrimitive>(global_scale: f32, scale: S) -> f32 {
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 63 | pub fn multiply_global_scale<S: CubePrimitive>(global_scale: f32, <cubecl_core::frontend::NativeExpand<S> as Into<_>>::into(scale): S) -> f32 {
[INFO] [stdout]    |                                                                   ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]   --> src/quant/dequantize.rs:85:9
[INFO] [stdout]    |
[INFO] [stdout] 85 |     for vector_idx in 0..value.vector_size() {
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 85 |     for <usize as Into<_>>::into(vector_idx) in 0..value.vector_size() {
[INFO] [stdout]    |         +++++++++++++++++++++++++          +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<u32>`
[INFO] [stdout]   --> src/quant/dequantize.rs:91:17
[INFO] [stdout]    |
[INFO] [stdout] 91 |             let value = (packed_val >> shift as u32) & mask;
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 91 |             let <cubecl_core::frontend::NativeExpand<u32> as Into<_>>::into(value) = (packed_val >> shift as u32) & mask;
[INFO] [stdout]    |                 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::ComptimeOptionExpand<Box<[f32]>>`
[INFO] [stdout]   --> src/quant/dequantize.rs:93:59
[INFO] [stdout]    |
[INFO] [stdout] 93 |             let float_value = cast_masked::<F, NP>(value, table.clone(), scheme);
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 93 |             let float_value = cast_masked::<F, NP>(value, <cubecl_core::frontend::ComptimeOptionExpand<Box<[f32]>> as Into<_>>::into(table.clone()), scheme);
[INFO] [stdout]    |                                                           +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++             +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::quant::scheme::QuantScheme`
[INFO] [stdout]   --> src/quant/dequantize.rs:74:17
[INFO] [stdout]    |
[INFO] [stdout] 74 |     #[comptime] scheme: QuantScheme,
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 74 |     #[comptime] <cubecl_core::quant::scheme::QuantScheme as Into<_>>::into(scheme): QuantScheme,
[INFO] [stdout]    |                 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]   --> src/quant/dequantize.rs:97:21
[INFO] [stdout]    |
[INFO] [stdout] 97 |                 let out_offset = out_offset + packed_idx + native_idx;
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 97 |                 let <usize as Into<_>>::into(out_offset) = out_offset + packed_idx + native_idx;
[INFO] [stdout]    |                     +++++++++++++++++++++++++          +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]   --> src/quant/dequantize.rs:96:17
[INFO] [stdout]    |
[INFO] [stdout] 96 |             for native_idx in 0..native_packing {
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 96 |             for <usize as Into<_>>::into(native_idx) in 0..native_packing {
[INFO] [stdout]    |                 +++++++++++++++++++++++++          +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<F>`
[INFO] [stdout]   --> src/quant/dequantize.rs:98:40
[INFO] [stdout]    |
[INFO] [stdout] 98 |                 out.insert(out_offset, float_value.extract(native_idx));
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 98 |                 out.insert(out_offset, <cubecl_core::frontend::NativeExpand<F> as Into<_>>::into(float_value.extract(native_idx)));
[INFO] [stdout]    |                                        ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++                               +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<u32>`
[INFO] [stdout]    --> src/quant/dequantize.rs:134:13
[INFO] [stdout]     |
[INFO] [stdout] 134 |         let field = (word >> shift) & mask;
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 134 |         let <cubecl_core::frontend::NativeExpand<u32> as Into<_>>::into(field) = (word >> shift) & mask;
[INFO] [stdout]     |             ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::ComptimeOptionExpand<Box<[f32]>>`
[INFO] [stdout]    --> src/quant/dequantize.rs:135:49
[INFO] [stdout]     |
[INFO] [stdout] 135 |         let value = cast_masked::<F, N1>(field, table.clone(), scheme);
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 135 |         let value = cast_masked::<F, N1>(field, <cubecl_core::frontend::ComptimeOptionExpand<Box<[f32]>> as Into<_>>::into(table.clone()), scheme);
[INFO] [stdout]     |                                                 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++             +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::quant::scheme::QuantScheme`
[INFO] [stdout]    --> src/quant/dequantize.rs:120:17
[INFO] [stdout]     |
[INFO] [stdout] 120 |     #[comptime] scheme: QuantScheme,
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 120 |     #[comptime] <cubecl_core::quant::scheme::QuantScheme as Into<_>>::into(scheme): QuantScheme,
[INFO] [stdout]     |                 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]    --> src/quant/dequantize.rs:132:9
[INFO] [stdout]     |
[INFO] [stdout] 132 |     for j in 0..NF::value() {
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 132 |     for <usize as Into<_>>::into(j) in 0..NF::value() {
[INFO] [stdout]     |         +++++++++++++++++++++++++ +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]    --> src/quant/dequantize.rs:136:37
[INFO] [stdout]     |
[INFO] [stdout] 136 |         out.insert(j, value.extract(0usize));
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 136 |         out.insert(j, value.extract(<usize as Into<_>>::into(0usize)));
[INFO] [stdout]     |                                     +++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<F>`
[INFO] [stdout]    --> src/quant/dequantize.rs:136:23
[INFO] [stdout]     |
[INFO] [stdout] 136 |         out.insert(j, value.extract(0usize));
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 136 |         out.insert(j, <cubecl_core::frontend::NativeExpand<F> as Into<_>>::into(value.extract(0usize)));
[INFO] [stdout]     |                       ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++                     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<u32>`
[INFO] [stdout]    --> src/quant/dequantize.rs:163:5
[INFO] [stdout]     |
[INFO] [stdout] 163 |     value: 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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 163 |     <cubecl_core::frontend::NativeExpand<u32> as Into<_>>::into(value): u32,
[INFO] [stdout]     |     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::quant::scheme::QuantScheme`
[INFO] [stdout]    --> src/quant/dequantize.rs:165:17
[INFO] [stdout]     |
[INFO] [stdout] 165 |     #[comptime] scheme: QuantScheme,
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 165 |     #[comptime] <cubecl_core::quant::scheme::QuantScheme as Into<_>>::into(scheme): QuantScheme,
[INFO] [stdout]     |                 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<cubecl_core::e5m2>`
[INFO] [stdout]    --> src/quant/dequantize.rs:185:55
[INFO] [stdout]     |
[INFO] [stdout] 185 |         QuantValue::E5M2 => Vector::<F, N>::cast_from(e5m2::from_bits(value as 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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 185 |         QuantValue::E5M2 => Vector::<F, N>::cast_from(<cubecl_core::frontend::NativeExpand<cubecl_core::e5m2> as Into<_>>::into(e5m2::from_bits(value as u8))),
[INFO] [stdout]     |                                                       ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++                            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<cubecl_core::e4m3>`
[INFO] [stdout]    --> src/quant/dequantize.rs:186:55
[INFO] [stdout]     |
[INFO] [stdout] 186 |         QuantValue::E4M3 => Vector::<F, N>::cast_from(e4m3::from_bits(value as 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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 186 |         QuantValue::E4M3 => Vector::<F, N>::cast_from(<cubecl_core::frontend::NativeExpand<cubecl_core::e4m3> as Into<_>>::into(e4m3::from_bits(value as u8))),
[INFO] [stdout]     |                                                       ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++                            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<u32>`
[INFO] [stdout]    --> src/quant/dequantize.rs:180:5
[INFO] [stdout]     |
[INFO] [stdout] 180 |     value: 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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 180 |     <cubecl_core::frontend::NativeExpand<u32> as Into<_>>::into(value): u32,
[INFO] [stdout]     |     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<i32>`
[INFO] [stdout]    --> src/quant/dequantize.rs:200:17
[INFO] [stdout]     |
[INFO] [stdout] 200 |             let signed_value = (value ^ sign_bit) as i32 - sign_bit as i32;
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 200 |             let <cubecl_core::frontend::NativeExpand<i32> as Into<_>>::into(signed_value) = (value ^ sign_bit) as i32 - sign_bit as i32;
[INFO] [stdout]     |                 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<F>`
[INFO] [stdout]   --> src/quant/round.rs:18:36
[INFO] [stdout]    |
[INFO] [stdout] 18 | pub fn round_up_to_dtype<F: Float>(scale: F, #[comptime] dtype: ScaleDtype) -> F {
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 18 | pub fn round_up_to_dtype<F: Float>(<cubecl_core::frontend::NativeExpand<F> as Into<_>>::into(scale): F, #[comptime] dtype: ScaleDtype) -> F {
[INFO] [stdout]    |                                    ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<f32>`
[INFO] [stdout]   --> src/quant/round.rs:23:34
[INFO] [stdout]    |
[INFO] [stdout] 23 |             F::cast_from(step_up(f32::cast_from(scale), dtype))
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 23 |             F::cast_from(step_up(<cubecl_core::frontend::NativeExpand<f32> as Into<_>>::into(f32::cast_from(scale)), dtype))
[INFO] [stdout]    |                                  ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++                     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::quant::scheme::ScaleDtype`
[INFO] [stdout]   --> src/quant/round.rs:18:58
[INFO] [stdout]    |
[INFO] [stdout] 18 | pub fn round_up_to_dtype<F: Float>(scale: F, #[comptime] dtype: ScaleDtype) -> F {
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 18 | pub fn round_up_to_dtype<F: Float>(scale: F, #[comptime] <cubecl_core::quant::scheme::ScaleDtype as Into<_>>::into(dtype): ScaleDtype) -> F {
[INFO] [stdout]    |                                                          ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<f32>`
[INFO] [stdout]   --> src/quant/round.rs:23:26
[INFO] [stdout]    |
[INFO] [stdout] 23 |             F::cast_from(step_up(f32::cast_from(scale), dtype))
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 23 |             F::cast_from(<cubecl_core::frontend::NativeExpand<f32> as Into<_>>::into(step_up(f32::cast_from(scale), dtype)))
[INFO] [stdout]    |                          ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++                                     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<f32>`
[INFO] [stdout]   --> src/quant/round.rs:25:67
[INFO] [stdout]    |
[INFO] [stdout] 25 |         ScaleDtype::UE8M0 => F::cast_from(step_up_to_power_of_two(f32::cast_from(scale))),
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 25 |         ScaleDtype::UE8M0 => F::cast_from(step_up_to_power_of_two(<cubecl_core::frontend::NativeExpand<f32> as Into<_>>::into(f32::cast_from(scale)))),
[INFO] [stdout]    |                                                                   ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++                     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<f32>`
[INFO] [stdout]   --> src/quant/round.rs:25:43
[INFO] [stdout]    |
[INFO] [stdout] 25 |         ScaleDtype::UE8M0 => F::cast_from(step_up_to_power_of_two(f32::cast_from(scale))),
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 25 |         ScaleDtype::UE8M0 => F::cast_from(<cubecl_core::frontend::NativeExpand<f32> as Into<_>>::into(step_up_to_power_of_two(f32::cast_from(scale)))),
[INFO] [stdout]    |                                           ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++                                              +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<f32>`
[INFO] [stdout]   --> src/quant/round.rs:36:28
[INFO] [stdout]    |
[INFO] [stdout] 36 | fn step_up_to_power_of_two(scale: f32) -> f32 {
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 36 | fn step_up_to_power_of_two(<cubecl_core::frontend::NativeExpand<f32> as Into<_>>::into(scale): f32) -> f32 {
[INFO] [stdout]    |                            ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<f32>`
[INFO] [stdout]   --> src/quant/round.rs:50:12
[INFO] [stdout]    |
[INFO] [stdout] 50 | fn step_up(scale: f32, #[comptime] dtype: ScaleDtype) -> f32 {
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 50 | fn step_up(<cubecl_core::frontend::NativeExpand<f32> as Into<_>>::into(scale): f32, #[comptime] dtype: ScaleDtype) -> f32 {
[INFO] [stdout]    |            ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::quant::scheme::F32Grid`
[INFO] [stdout]   --> src/quant/round.rs:55:9
[INFO] [stdout]    |
[INFO] [stdout] 55 |     let grid = comptime!(dtype.f32_grid());
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 55 |     let <cubecl_core::quant::scheme::F32Grid as Into<_>>::into(grid) = comptime!(dtype.f32_grid());
[INFO] [stdout]    |         +++++++++++++++++++++++++++++++++++++++++++++++++++++++    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<f32>`
[INFO] [stdout]   --> src/quant/round.rs:80:21
[INFO] [stdout]    |
[INFO] [stdout] 80 | fn round_up_on_grid(scale: f32, #[comptime] grid: F32Grid) -> f32 {
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 80 | fn round_up_on_grid(<cubecl_core::frontend::NativeExpand<f32> as Into<_>>::into(scale): f32, #[comptime] grid: F32Grid) -> f32 {
[INFO] [stdout]    |                     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<u32>`
[INFO] [stdout]   --> src/quant/round.rs:82:9
[INFO] [stdout]    |
[INFO] [stdout] 82 |     let up_bits = (bits + comptime!(grid.round_up_bias())) & comptime!(grid.truncate_mask());
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 82 |     let <cubecl_core::frontend::NativeExpand<u32> as Into<_>>::into(up_bits) = (bits + comptime!(grid.round_up_bias())) & comptime!(grid.truncate_mask());
[INFO] [stdout]    |         ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<usize>`
[INFO] [stdout]   --> src/tensor/contiguous/base.rs:35:9
[INFO] [stdout]    |
[INFO] [stdout] 35 |     for i in dim_start..dim_end {
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 35 |     for <cubecl_core::frontend::NativeExpand<usize> as Into<_>>::into(i) in dim_start..dim_end {
[INFO] [stdout]    |         ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<usize>`
[INFO] [stdout]   --> src/tensor/contiguous/base.rs:59:13
[INFO] [stdout]    |
[INFO] [stdout] 59 |         let dim = rank - i - 1;
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 59 |         let <cubecl_core::frontend::NativeExpand<usize> as Into<_>>::into(dim) = rank - i - 1;
[INFO] [stdout]    |             ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<usize>`
[INFO] [stdout]   --> src/tensor/contiguous/base.rs:81:13
[INFO] [stdout]    |
[INFO] [stdout] 81 |     let mut remainder = offset_ref;
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 81 |     let mut <cubecl_core::frontend::NativeExpand<usize> as Into<_>>::into(remainder) = offset_ref;
[INFO] [stdout]    |             ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++         +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]    --> src/tensor/contiguous/base.rs:100:17
[INFO] [stdout]     |
[INFO] [stdout] 100 |     #[comptime] elems_per_thread: usize,
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 100 |     #[comptime] <usize as Into<_>>::into(elems_per_thread): usize,
[INFO] [stdout]     |                 +++++++++++++++++++++++++                +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<usize>`
[INFO] [stdout]    --> src/tensor/contiguous/base.rs:103:9
[INFO] [stdout]     |
[INFO] [stdout] 103 |     let offset_linear = ABSOLUTE_POS * elems_per_thread;
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 103 |     let <cubecl_core::frontend::NativeExpand<usize> as Into<_>>::into(offset_linear) = ABSOLUTE_POS * elems_per_thread;
[INFO] [stdout]     |         ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++             +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&mut cubecl_core::frontend::NativeExpand<[cubecl_core::frontend::Vector<T, N>]>`
[INFO] [stdout]   --> src/tensor/contiguous/base.rs:98:5
[INFO] [stdout]    |
[INFO] [stdout] 98 |     output: &mut [Vector<T, N>],
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 98 |     <&mut cubecl_core::frontend::NativeExpand<[cubecl_core::frontend::Vector<T, N>]> as Into<_>>::into(output): &mut [Vector<T, N>],
[INFO] [stdout]    |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]    --> src/tensor/contiguous/base.rs:129:9
[INFO] [stdout]     |
[INFO] [stdout] 129 |     let vectors_per_thread = elems_per_thread / vector_size;
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 129 |     let <usize as Into<_>>::into(vectors_per_thread) = elems_per_thread / vector_size;
[INFO] [stdout]     |         +++++++++++++++++++++++++                  +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]    --> src/tensor/contiguous/base.rs:141:13
[INFO] [stdout]     |
[INFO] [stdout] 141 |         for k in 0..vector_size {
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 141 |         for <usize as Into<_>>::into(k) in 0..vector_size {
[INFO] [stdout]     |             +++++++++++++++++++++++++ +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<usize>`
[INFO] [stdout]    --> src/tensor/contiguous/base.rs:142:17
[INFO] [stdout]     |
[INFO] [stdout] 142 |             let offset_input = offset_input + offset + k;
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 142 |             let <cubecl_core::frontend::NativeExpand<usize> as Into<_>>::into(offset_input) = offset_input + offset + k;
[INFO] [stdout]     |                 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<T>`
[INFO] [stdout]    --> src/tensor/contiguous/base.rs:143:27
[INFO] [stdout]     |
[INFO] [stdout] 143 |             reg.insert(k, input.read_checked(offset_input));
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 143 |             reg.insert(k, <cubecl_core::frontend::NativeExpand<T> as Into<_>>::into(input.read_checked(offset_input)));
[INFO] [stdout]     |                           ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++                                +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<usize>`
[INFO] [stdout]    --> src/tensor/contiguous/base.rs:131:9
[INFO] [stdout]     |
[INFO] [stdout] 131 |     let offset_output = ABSOLUTE_POS * vectors_per_thread;
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 131 |     let <cubecl_core::frontend::NativeExpand<usize> as Into<_>>::into(offset_output) = ABSOLUTE_POS * vectors_per_thread;
[INFO] [stdout]     |         ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++             +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&mut cubecl_core::frontend::NativeExpand<[cubecl_core::frontend::Vector<T, N>]>`
[INFO] [stdout]    --> src/tensor/contiguous/base.rs:123:5
[INFO] [stdout]     |
[INFO] [stdout] 123 |     output: &mut [Vector<T, N>],
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 123 |     <&mut cubecl_core::frontend::NativeExpand<[cubecl_core::frontend::Vector<T, N>]> as Into<_>>::into(output): &mut [Vector<T, N>],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<usize>`
[INFO] [stdout]    --> src/tensor/contiguous/base.rs:176:17
[INFO] [stdout]     |
[INFO] [stdout] 176 |         let mut remainder = elem_pos + n;
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 176 |         let mut <cubecl_core::frontend::NativeExpand<usize> as Into<_>>::into(remainder) = elem_pos + n;
[INFO] [stdout]     |                 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++         +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<usize>`
[INFO] [stdout]    --> src/tensor/contiguous/base.rs:192:13
[INFO] [stdout]     |
[INFO] [stdout] 192 |         let shift_in = packing_offset * bits_per_elem;
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 192 |         let <cubecl_core::frontend::NativeExpand<usize> as Into<_>>::into(shift_in) = packing_offset * bits_per_elem;
[INFO] [stdout]     |             ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<usize>`
[INFO] [stdout]    --> src/tensor/contiguous/base.rs:193:13
[INFO] [stdout]     |
[INFO] [stdout] 193 |         let shift_out = n * bits_per_elem;
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 193 |         let <cubecl_core::frontend::NativeExpand<usize> as Into<_>>::into(shift_out) = n * bits_per_elem;
[INFO] [stdout]     |             ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++         +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]    --> src/tensor/contiguous/base.rs:214:9
[INFO] [stdout]     |
[INFO] [stdout] 214 |     let vectors_per_thread = elems_per_thread / vector_size;
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 214 |     let <usize as Into<_>>::into(vectors_per_thread) = elems_per_thread / vector_size;
[INFO] [stdout]     |         +++++++++++++++++++++++++                  +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]    --> src/tensor/contiguous/base.rs:230:13
[INFO] [stdout]     |
[INFO] [stdout] 230 |         for k in 0..vector_size {
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 230 |         for <usize as Into<_>>::into(k) in 0..vector_size {
[INFO] [stdout]     |             +++++++++++++++++++++++++ +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl_core::frontend::TensorExpand<T>`
[INFO] [stdout]    --> src/tensor/contiguous/base.rs:203:5
[INFO] [stdout]     |
[INFO] [stdout] 203 |     input: &Tensor<T>,
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 203 |     <&cubecl_core::frontend::TensorExpand<T> as Into<_>>::into(input): &Tensor<T>,
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<usize>`
[INFO] [stdout]    --> src/tensor/contiguous/base.rs:231:17
[INFO] [stdout]     |
[INFO] [stdout] 231 |             let offset_input = offset_input + offset + k;
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 231 |             let <cubecl_core::frontend::NativeExpand<usize> as Into<_>>::into(offset_input) = offset_input + offset + k;
[INFO] [stdout]     |                 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]    --> src/tensor/contiguous/base.rs:207:17
[INFO] [stdout]     |
[INFO] [stdout] 207 |     #[comptime] packed_dim: usize,
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 207 |     #[comptime] <usize as Into<_>>::into(packed_dim): usize,
[INFO] [stdout]     |                 +++++++++++++++++++++++++          +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]    --> src/tensor/contiguous/base.rs:208:17
[INFO] [stdout]     |
[INFO] [stdout] 208 |     #[comptime] packing: usize,
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 208 |     #[comptime] <usize as Into<_>>::into(packing): usize,
[INFO] [stdout]     |                 +++++++++++++++++++++++++       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]    --> src/tensor/contiguous/base.rs:209:17
[INFO] [stdout]     |
[INFO] [stdout] 209 |     #[comptime] rank: usize,
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 209 |     #[comptime] <usize as Into<_>>::into(rank): usize,
[INFO] [stdout]     |                 +++++++++++++++++++++++++    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<T>`
[INFO] [stdout]    --> src/tensor/contiguous/base.rs:235:17
[INFO] [stdout]     |
[INFO] [stdout] 235 |                 index_packed(input, offset_input, &in_shape, packed_dim, packing, rank),
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 235 |                 <cubecl_core::frontend::NativeExpand<T> as Into<_>>::into(index_packed(input, offset_input, &in_shape, packed_dim, packing, rank)),
[INFO] [stdout]     |                 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<usize>`
[INFO] [stdout]    --> src/tensor/contiguous/base.rs:216:9
[INFO] [stdout]     |
[INFO] [stdout] 216 |     let offset_output = ABSOLUTE_POS * vectors_per_thread;
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 216 |     let <cubecl_core::frontend::NativeExpand<usize> as Into<_>>::into(offset_output) = ABSOLUTE_POS * vectors_per_thread;
[INFO] [stdout]     |         ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++             +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<usize>`
[INFO] [stdout]   --> src/tensor/contiguous/perpendicular.rs:23:9
[INFO] [stdout]    |
[INFO] [stdout] 23 |     let last_axis = input.rank() - 1;
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 23 |     let <cubecl_core::frontend::NativeExpand<usize> as Into<_>>::into(last_axis) = input.rank() - 1;
[INFO] [stdout]    |         ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++         +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<cubecl_core::frontend::Vector<T, N>>`
[INFO] [stdout]   --> src/tensor/contiguous/perpendicular.rs:33:27
[INFO] [stdout]    |
[INFO] [stdout] 33 |         accumulators.push(Vector::empty());
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 33 |         accumulators.push(<cubecl_core::frontend::NativeExpand<cubecl_core::frontend::Vector<T, N>> as Into<_>>::into(Vector::empty()));
[INFO] [stdout]    |                           ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++               +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<usize>`
[INFO] [stdout]   --> src/tensor/contiguous/perpendicular.rs:19:5
[INFO] [stdout]    |
[INFO] [stdout] 19 |     axis_vectorized: usize,
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 19 |     <cubecl_core::frontend::NativeExpand<usize> as Into<_>>::into(axis_vectorized): usize,
[INFO] [stdout]    |     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++               +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<usize>`
[INFO] [stdout]   --> src/tensor/contiguous/perpendicular.rs:62:13
[INFO] [stdout]    |
[INFO] [stdout] 62 |         for axis in 0..input.rank() {
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 62 |         for <cubecl_core::frontend::NativeExpand<usize> as Into<_>>::into(axis) in 0..input.rank() {
[INFO] [stdout]    |             ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]   --> src/tensor/contiguous/perpendicular.rs:72:13
[INFO] [stdout]    |
[INFO] [stdout] 72 |         for i in 0..vector_size {
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 72 |         for <usize as Into<_>>::into(i) in 0..vector_size {
[INFO] [stdout]    |             +++++++++++++++++++++++++ +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]   --> src/tensor/contiguous/perpendicular.rs:79:17
[INFO] [stdout]    |
[INFO] [stdout] 79 |             for o in 0..vector_size {
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 79 |             for <usize as Into<_>>::into(o) in 0..vector_size {
[INFO] [stdout]    |                 +++++++++++++++++++++++++ +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<T>`
[INFO] [stdout]   --> src/tensor/contiguous/perpendicular.rs:81:34
[INFO] [stdout]    |
[INFO] [stdout] 81 |                 vector.insert(i, batched.extract(o));
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 81 |                 vector.insert(i, <cubecl_core::frontend::NativeExpand<T> as Into<_>>::into(batched.extract(o)));
[INFO] [stdout]    |                                  ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++                  +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<C>`
[INFO] [stdout]    --> src/tensor/handle.rs:199:54
[INFO] [stdout]     |
[INFO] [stdout] 199 |             output[ABSOLUTE_POS] = Vector::cast_from(C::from_int(0));
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 199 |             output[ABSOLUTE_POS] = Vector::cast_from(<cubecl_core::frontend::NativeExpand<C> as Into<_>>::into(C::from_int(0)));
[INFO] [stdout]     |                                                      ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++              +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<C>`
[INFO] [stdout]   --> src/tensor/identity.rs:18:38
[INFO] [stdout]    |
[INFO] [stdout] 18 |         let mut vector = Vector::new(C::from_int(0));
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 18 |         let mut vector = Vector::new(<cubecl_core::frontend::NativeExpand<C> as Into<_>>::into(C::from_int(0)));
[INFO] [stdout]    |                                      ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++              +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<usize>`
[INFO] [stdout]   --> src/tensor/identity.rs:22:17
[INFO] [stdout]    |
[INFO] [stdout] 22 |         let mut offset = 0;
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 22 |         let mut <cubecl_core::frontend::NativeExpand<usize> as Into<_>>::into(offset) = 0;
[INFO] [stdout]    |                 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<C>`
[INFO] [stdout]   --> src/tensor/identity.rs:26:47
[INFO] [stdout]    |
[INFO] [stdout] 26 |                 vector.insert_dynamic(offset, C::from_int(1));
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 26 |                 vector.insert_dynamic(offset, <cubecl_core::frontend::NativeExpand<C> as Into<_>>::into(C::from_int(1)));
[INFO] [stdout]    |                                               ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++              +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<T as cubecl_core::frontend::CubeType>::ExpandType`
[INFO] [stdout]    --> src/tensor/layout/coordinates.rs:118:22
[INFO] [stdout]     |
[INFO] [stdout] 118 |             out.push(T::add(this[i], other[i]));
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 118 |             out.push(<<T as cubecl_core::frontend::CubeType>::ExpandType as Into<_>>::into(T::add(this[i], other[i])));
[INFO] [stdout]     |                      ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++                         +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<T as cubecl_core::frontend::CubeType>::ExpandType`
[INFO] [stdout]    --> src/tensor/layout/coordinates.rs:130:22
[INFO] [stdout]     |
[INFO] [stdout] 130 |             out.push(T::sub(this[i], other[i]));
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 130 |             out.push(<<T as cubecl_core::frontend::CubeType>::ExpandType as Into<_>>::into(T::sub(this[i], other[i])));
[INFO] [stdout]     |                      ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++                         +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<T as cubecl_core::frontend::CubeType>::ExpandType`
[INFO] [stdout]    --> src/tensor/layout/coordinates.rs:142:22
[INFO] [stdout]     |
[INFO] [stdout] 142 |             out.push(T::min(this[i], other[i]));
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 142 |             out.push(<<T as cubecl_core::frontend::CubeType>::ExpandType as Into<_>>::into(T::min(this[i], other[i])));
[INFO] [stdout]     |                      ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++                         +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<T as cubecl_core::frontend::CubeType>::ExpandType`
[INFO] [stdout]    --> src/tensor/layout/coordinates.rs:154:22
[INFO] [stdout]     |
[INFO] [stdout] 154 |             out.push(T::max(this[i], other[i]));
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 154 |             out.push(<<T as cubecl_core::frontend::CubeType>::ExpandType as Into<_>>::into(T::max(this[i], other[i])));
[INFO] [stdout]     |                      ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++                         +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i64`
[INFO] [stdout]    --> src/tensor/layout/coordinates.rs:172:41
[INFO] [stdout]     |
[INFO] [stdout] 172 |     fn from_int(this: Self, #[comptime] value: i64) -> Self {
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 172 |     fn from_int(this: Self, #[comptime] <i64 as Into<_>>::into(value): i64) -> Self {
[INFO] [stdout]     |                                         +++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<T as cubecl_core::frontend::CubeType>::ExpandType`
[INFO] [stdout]    --> src/tensor/layout/coordinates.rs:178:25
[INFO] [stdout]     |
[INFO] [stdout] 178 |             origin.push(T::from_int(this[i], value));
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 178 |             origin.push(<<T as cubecl_core::frontend::CubeType>::ExpandType as Into<_>>::into(T::from_int(this[i], value)));
[INFO] [stdout]     |                         ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++                           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<u32>`
[INFO] [stdout]   --> src/tensor/layout/as_dyn.rs:48:13
[INFO] [stdout]    |
[INFO] [stdout] 48 |         for x in self {
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 48 |         for <cubecl_core::frontend::NativeExpand<u32> as Into<_>>::into(x) in self {
[INFO] [stdout]    |             ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<i32>`
[INFO] [stdout]   --> src/tensor/layout/as_dyn.rs:49:22
[INFO] [stdout]    |
[INFO] [stdout] 49 |             seq.push(i32::cast_from(x));
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 49 |             seq.push(<cubecl_core::frontend::NativeExpand<i32> as Into<_>>::into(i32::cast_from(x)));
[INFO] [stdout]    |                      ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<<L as Layout>::Coordinates as CubeType>::ExpandType`
[INFO] [stdout]    --> src/tensor/layout/as_dyn.rs:159:29
[INFO] [stdout]     |
[INFO] [stdout] 159 |     fn to_source_pos(&self, pos: Self::Coordinates) -> Self::SourceCoordinates {
[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: the full name for the type has been written to '/opt/rustwide/target/debug/build/cubecl-std/951faf6648960f40/out/cubecl_std-951faf6648960f40.long-type-15912098227834820249.txt'
[INFO] [stdout]     = note: consider using `--verbose` to print the full type name to the console
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 159 |     fn to_source_pos(&self, <<<L as tensor::layout::base::Layout>::Coordinates as cubecl_core::frontend::CubeType>::ExpandType as Into<_>>::into(pos): Self::Coordinates) -> Self::SourceCoordinates {
[INFO] [stdout]     |                             +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<<L as Layout>::Coordinates as CubeType>::ExpandType`
[INFO] [stdout]    --> src/tensor/layout/as_dyn.rs:164:28
[INFO] [stdout]     |
[INFO] [stdout] 164 |     fn is_in_bounds(&self, pos: Self::Coordinates) -> bool {
[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: the full name for the type has been written to '/opt/rustwide/target/debug/build/cubecl-std/951faf6648960f40/out/cubecl_std-951faf6648960f40.long-type-15912098227834820249.txt'
[INFO] [stdout]     = note: consider using `--verbose` to print the full type name to the console
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 164 |     fn is_in_bounds(&self, <<<L as tensor::layout::base::Layout>::Coordinates as cubecl_core::frontend::CubeType>::ExpandType as Into<_>>::into(pos): Self::Coordinates) -> bool {
[INFO] [stdout]     |                            +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<<L as Layout>::Coordinates as CubeType>::ExpandType`
[INFO] [stdout]    --> src/tensor/layout/as_dyn.rs:168:37
[INFO] [stdout]     |
[INFO] [stdout] 168 |     fn to_source_pos_checked(&self, pos: Self::Coordinates) -> (Self::SourceCoordinates, bool) {
[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: the full name for the type has been written to '/opt/rustwide/target/debug/build/cubecl-std/951faf6648960f40/out/cubecl_std-951faf6648960f40.long-type-15912098227834820249.txt'
[INFO] [stdout]     = note: consider using `--verbose` to print the full type name to the console
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 168 |     fn to_source_pos_checked(&self, <<<L as tensor::layout::base::Layout>::Coordinates as cubecl_core::frontend::CubeType>::ExpandType as Into<_>>::into(pos): Self::Coordinates) -> (Self::SourceCoordinates, bool) {
[INFO] [stdout]     |                                     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<<L as Layout>::Coordinates as CubeType>::ExpandType`
[INFO] [stdout]    --> src/tensor/layout/as_dyn.rs:188:29
[INFO] [stdout]     |
[INFO] [stdout] 188 |     fn to_source_pos(&self, pos: Self::Coordinates) -> Self::SourceCoordinates {
[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: the full name for the type has been written to '/opt/rustwide/target/debug/build/cubecl-std/951faf6648960f40/out/cubecl_std-951faf6648960f40.long-type-15912098227834820249.txt'
[INFO] [stdout]     = note: consider using `--verbose` to print the full type name to the console
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 188 |     fn to_source_pos(&self, <<<L as tensor::layout::base::Layout>::Coordinates as cubecl_core::frontend::CubeType>::ExpandType as Into<_>>::into(pos): Self::Coordinates) -> Self::SourceCoordinates {
[INFO] [stdout]     |                             +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<<L as Layout>::Coordinates as CubeType>::ExpandType`
[INFO] [stdout]    --> src/tensor/layout/as_dyn.rs:193:28
[INFO] [stdout]     |
[INFO] [stdout] 193 |     fn is_in_bounds(&self, pos: Self::Coordinates) -> bool {
[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: the full name for the type has been written to '/opt/rustwide/target/debug/build/cubecl-std/951faf6648960f40/out/cubecl_std-951faf6648960f40.long-type-15912098227834820249.txt'
[INFO] [stdout]     = note: consider using `--verbose` to print the full type name to the console
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 193 |     fn is_in_bounds(&self, <<<L as tensor::layout::base::Layout>::Coordinates as cubecl_core::frontend::CubeType>::ExpandType as Into<_>>::into(pos): Self::Coordinates) -> bool {
[INFO] [stdout]     |                            +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<<L as Layout>::Coordinates as CubeType>::ExpandType`
[INFO] [stdout]    --> src/tensor/layout/as_dyn.rs:197:37
[INFO] [stdout]     |
[INFO] [stdout] 197 |     fn to_source_pos_checked(&self, pos: Self::Coordinates) -> (Self::SourceCoordinates, bool) {
[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: the full name for the type has been written to '/opt/rustwide/target/debug/build/cubecl-std/951faf6648960f40/out/cubecl_std-951faf6648960f40.long-type-15912098227834820249.txt'
[INFO] [stdout]     = note: consider using `--verbose` to print the full type name to the console
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 197 |     fn to_source_pos_checked(&self, <<<L as tensor::layout::base::Layout>::Coordinates as cubecl_core::frontend::CubeType>::ExpandType as Into<_>>::into(pos): Self::Coordinates) -> (Self::SourceCoordinates, bool) {
[INFO] [stdout]     |                                     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<<L1 as Layout>::Coordinates as CubeType>::ExpandType`
[INFO] [stdout]   --> src/tensor/layout/chain.rs:25:29
[INFO] [stdout]    |
[INFO] [stdout] 25 |     fn to_source_pos(&self, pos: Self::Coordinates) -> Self::SourceCoordinates {
[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: the full name for the type has been written to '/opt/rustwide/target/debug/build/cubecl-std/951faf6648960f40/out/cubecl_std-951faf6648960f40.long-type-15543421569257522603.txt'
[INFO] [stdout]    = note: consider using `--verbose` to print the full type name to the console
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 25 |     fn to_source_pos(&self, <<<L1 as tensor::layout::base::Layout>::Coordinates as cubecl_core::frontend::CubeType>::ExpandType as Into<_>>::into(pos): Self::Coordinates) -> Self::SourceCoordinates {
[INFO] [stdout]    |                             ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<<L0 as Layout>::Coordinates as CubeType>::ExpandType`
[INFO] [stdout]   --> src/tensor/layout/chain.rs:26:13
[INFO] [stdout]    |
[INFO] [stdout] 26 |         let pos = self.l1.to_source_pos(pos);
[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: the full name for the type has been written to '/opt/rustwide/target/debug/build/cubecl-std/951faf6648960f40/out/cubecl_std-951faf6648960f40.long-type-3304540164491277840.txt'
[INFO] [stdout]    = note: consider using `--verbose` to print the full type name to the console
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 26 |         let <<<L0 as tensor::layout::base::Layout>::Coordinates as cubecl_core::frontend::CubeType>::ExpandType as Into<_>>::into(pos) = self.l1.to_source_pos(pos);
[INFO] [stdout]    |             ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<<L1 as Layout>::Coordinates as CubeType>::ExpandType`
[INFO] [stdout]   --> src/tensor/layout/chain.rs:30:28
[INFO] [stdout]    |
[INFO] [stdout] 30 |     fn is_in_bounds(&self, pos: Self::Coordinates) -> bool {
[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: the full name for the type has been written to '/opt/rustwide/target/debug/build/cubecl-std/951faf6648960f40/out/cubecl_std-951faf6648960f40.long-type-15543421569257522603.txt'
[INFO] [stdout]    = note: consider using `--verbose` to print the full type name to the console
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 30 |     fn is_in_bounds(&self, <<<L1 as tensor::layout::base::Layout>::Coordinates as cubecl_core::frontend::CubeType>::ExpandType as Into<_>>::into(pos): Self::Coordinates) -> bool {
[INFO] [stdout]    |                            ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<<L0 as Layout>::Coordinates as CubeType>::ExpandType`
[INFO] [stdout]   --> src/tensor/layout/chain.rs:31:14
[INFO] [stdout]    |
[INFO] [stdout] 31 |         let (pos, l1_in_bounds) = self.l1.to_source_pos_checked(pos);
[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: the full name for the type has been written to '/opt/rustwide/target/debug/build/cubecl-std/951faf6648960f40/out/cubecl_std-951faf6648960f40.long-type-3304540164491277840.txt'
[INFO] [stdout]    = note: consider using `--verbose` to print the full type name to the console
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 31 |         let (<<<L0 as tensor::layout::base::Layout>::Coordinates as cubecl_core::frontend::CubeType>::ExpandType as Into<_>>::into(pos), l1_in_bounds) = self.l1.to_source_pos_checked(pos);
[INFO] [stdout]    |              ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<<L1 as Layout>::Coordinates as CubeType>::ExpandType`
[INFO] [stdout]   --> src/tensor/layout/chain.rs:35:37
[INFO] [stdout]    |
[INFO] [stdout] 35 |     fn to_source_pos_checked(&self, pos: Self::Coordinates) -> (Self::SourceCoordinates, bool) {
[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: the full name for the type has been written to '/opt/rustwide/target/debug/build/cubecl-std/951faf6648960f40/out/cubecl_std-951faf6648960f40.long-type-15543421569257522603.txt'
[INFO] [stdout]    = note: consider using `--verbose` to print the full type name to the console
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 35 |     fn to_source_pos_checked(&self, <<<L1 as tensor::layout::base::Layout>::Coordinates as cubecl_core::frontend::CubeType>::ExpandType as Into<_>>::into(pos): Self::Coordinates) -> (Self::SourceCoordinates, bool) {
[INFO] [stdout]    |                                     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<<L0 as Layout>::Coordinates as CubeType>::ExpandType`
[INFO] [stdout]   --> src/tensor/layout/chain.rs:36:14
[INFO] [stdout]    |
[INFO] [stdout] 36 |         let (pos, l1_in_bounds) = self.l1.to_source_pos_checked(pos);
[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: the full name for the type has been written to '/opt/rustwide/target/debug/build/cubecl-std/951faf6648960f40/out/cubecl_std-951faf6648960f40.long-type-3304540164491277840.txt'
[INFO] [stdout]    = note: consider using `--verbose` to print the full type name to the console
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 36 |         let (<<<L0 as tensor::layout::base::Layout>::Coordinates as cubecl_core::frontend::CubeType>::ExpandType as Into<_>>::into(pos), l1_in_bounds) = self.l1.to_source_pos_checked(pos);
[INFO] [stdout]    |              ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::SequenceExpand<u32>`
[INFO] [stdout]   --> src/tensor/layout/dynamic_rank_strided.rs:36:29
[INFO] [stdout]    |
[INFO] [stdout] 36 |         (self.to_source_pos(pos.clone()), self.is_in_bounds(pos))
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 36 |         (self.to_source_pos(<cubecl_core::frontend::SequenceExpand<u32> as Into<_>>::into(pos.clone())), self.is_in_bounds(pos))
[INFO] [stdout]    |                             ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::SequenceExpand<u32>`
[INFO] [stdout]   --> src/tensor/layout/dynamic_rank_strided.rs:35:37
[INFO] [stdout]    |
[INFO] [stdout] 35 |     fn to_source_pos_checked(&self, pos: Self::Coordinates) -> (Self::SourceCoordinates, bool) {
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 35 |     fn to_source_pos_checked(&self, <cubecl_core::frontend::SequenceExpand<u32> as Into<_>>::into(pos): Self::Coordinates) -> (Self::SourceCoordinates, bool) {
[INFO] [stdout]    |                                     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<D as cubecl_core::frontend::CubeType>::ExpandType`
[INFO] [stdout]   --> src/tensor/layout/fixed_dim.rs:68:29
[INFO] [stdout]    |
[INFO] [stdout] 68 |         (self.to_source_pos(pos.clone()), self.is_in_bounds(pos))
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 68 |         (self.to_source_pos(<<D as cubecl_core::frontend::CubeType>::ExpandType as Into<_>>::into(pos.clone())), self.is_in_bounds(pos))
[INFO] [stdout]    |                             ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<D as cubecl_core::frontend::CubeType>::ExpandType`
[INFO] [stdout]   --> src/tensor/layout/fixed_dim.rs:67:37
[INFO] [stdout]    |
[INFO] [stdout] 67 |     fn to_source_pos_checked(&self, pos: Self::Coordinates) -> (Self::SourceCoordinates, bool) {
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 67 |     fn to_source_pos_checked(&self, <<D as cubecl_core::frontend::CubeType>::ExpandType as Into<_>>::into(pos): Self::Coordinates) -> (Self::SourceCoordinates, bool) {
[INFO] [stdout]    |                                     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<usize>`
[INFO] [stdout]    --> src/tensor/layout/linear.rs:141:37
[INFO] [stdout]     |
[INFO] [stdout] 141 |     fn to_source_pos_checked(&self, pos: Self::Coordinates) -> (usize, bool) {
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 141 |     fn to_source_pos_checked(&self, <cubecl_core::frontend::NativeExpand<usize> as Into<_>>::into(pos): Self::Coordinates) -> (usize, bool) {
[INFO] [stdout]     |                                     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<usize>`
[INFO] [stdout]    --> src/tensor/layout/permuted.rs:145:29
[INFO] [stdout]     |
[INFO] [stdout] 145 |     fn to_source_pos(&self, pos: Self::Coordinates) -> usize {
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 145 |     fn to_source_pos(&self, <cubecl_core::frontend::NativeExpand<usize> as Into<_>>::into(pos): Self::Coordinates) -> usize {
[INFO] [stdout]     |                             ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]    --> src/tensor/layout/permuted.rs:145:22
[INFO] [stdout]     |
[INFO] [stdout] 145 |       fn to_source_pos(&self, pos: Self::Coordinates) -> usize {
[INFO] [stdout]     |  ______________________^
[INFO] [stdout] 146 | |         index_offset_contiguous_fastdivmod(pos, &self.shape, &self.strides, self.vector_size)
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 145 ~     fn to_source_pos(<usize as Into<_>>::into(&self, pos: Self::Coordinates) -> usize {
[INFO] [stdout] 146 ~         index_offset_contiguous_fastdivmod(pos, &self.shape, &self.strides, self.vector_size))
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<usize>`
[INFO] [stdout]    --> src/tensor/layout/permuted.rs:149:37
[INFO] [stdout]     |
[INFO] [stdout] 149 |     fn to_source_pos_checked(&self, pos: Self::Coordinates) -> (usize, bool) {
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 149 |     fn to_source_pos_checked(&self, <cubecl_core::frontend::NativeExpand<usize> as Into<_>>::into(pos): Self::Coordinates) -> (usize, bool) {
[INFO] [stdout]     |                                     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<usize>`
[INFO] [stdout]   --> src/tensor/layout/plain.rs:54:37
[INFO] [stdout]    |
[INFO] [stdout] 54 |     fn to_source_pos_checked(&self, pos: Self::Coordinates) -> (usize, bool) {
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 54 |     fn to_source_pos_checked(&self, <cubecl_core::frontend::NativeExpand<usize> as Into<_>>::into(pos): Self::Coordinates) -> (usize, bool) {
[INFO] [stdout]    |                                     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<usize>`
[INFO] [stdout]   --> src/tensor/layout/simple.rs:46:37
[INFO] [stdout]    |
[INFO] [stdout] 46 |     fn to_source_pos_checked(&self, pos: Self::Coordinates) -> (usize, bool) {
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 46 |     fn to_source_pos_checked(&self, <cubecl_core::frontend::NativeExpand<usize> as Into<_>>::into(pos): Self::Coordinates) -> (usize, bool) {
[INFO] [stdout]    |                                     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<C as cubecl_core::frontend::CubeType>::ExpandType`
[INFO] [stdout]   --> src/tensor/layout/slice.rs:47:16
[INFO] [stdout]    |
[INFO] [stdout] 47 |         C::add(self.offset(), pos)
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 47 |         C::add(<<C as cubecl_core::frontend::CubeType>::ExpandType as Into<_>>::into(self.offset()), pos)
[INFO] [stdout]    |                ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++             +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<C as cubecl_core::frontend::CubeType>::ExpandType`
[INFO] [stdout]   --> src/tensor/layout/slice.rs:46:29
[INFO] [stdout]    |
[INFO] [stdout] 46 |     fn to_source_pos(&self, pos: Self::Coordinates) -> Self::SourceCoordinates {
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 46 |     fn to_source_pos(&self, <<C as cubecl_core::frontend::CubeType>::ExpandType as Into<_>>::into(pos): Self::Coordinates) -> Self::SourceCoordinates {
[INFO] [stdout]    |                             ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<C as cubecl_core::frontend::CubeType>::ExpandType`
[INFO] [stdout]   --> src/tensor/layout/slice.rs:50:28
[INFO] [stdout]    |
[INFO] [stdout] 50 |     fn is_in_bounds(&self, pos: Self::Coordinates) -> bool {
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 50 |     fn is_in_bounds(&self, <<C as cubecl_core::frontend::CubeType>::ExpandType as Into<_>>::into(pos): Self::Coordinates) -> bool {
[INFO] [stdout]    |                            ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<C as cubecl_core::frontend::CubeType>::ExpandType`
[INFO] [stdout]   --> src/tensor/layout/slice.rs:53:34
[INFO] [stdout]    |
[INFO] [stdout] 53 |             C::is_in_bounds(pos, self.size.clone())
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 53 |             C::is_in_bounds(pos, <<C as cubecl_core::frontend::CubeType>::ExpandType as Into<_>>::into(self.size.clone()))
[INFO] [stdout]    |                                  ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<usize>`
[INFO] [stdout]   --> src/tensor/layout/strided.rs:70:13
[INFO] [stdout]    |
[INFO] [stdout] 70 |         let offset_abs = pos * self.vector_size;
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 70 |         let <cubecl_core::frontend::NativeExpand<usize> as Into<_>>::into(offset_abs) = pos * self.vector_size;
[INFO] [stdout]    |             ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++          +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<usize>`
[INFO] [stdout]   --> src/tensor/layout/strided.rs:76:37
[INFO] [stdout]    |
[INFO] [stdout] 76 |     fn to_source_pos_checked(&self, pos: Self::Coordinates) -> (usize, bool) {
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 76 |     fn to_source_pos_checked(&self, <cubecl_core::frontend::NativeExpand<usize> as Into<_>>::into(pos): Self::Coordinates) -> (usize, bool) {
[INFO] [stdout]    |                                     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<u32>`
[INFO] [stdout]   --> src/tensor/layout/tiled_view.rs:78:21
[INFO] [stdout]    |
[INFO] [stdout] 78 |                 let digit = pos[comptime!(self.start_axis + i)] / divisor;
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 78 |                 let <cubecl_core::frontend::NativeExpand<u32> as Into<_>>::into(digit) = pos[comptime!(self.start_axis + i)] / divisor;
[INFO] [stdout]    |                     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::SequenceExpand<u32>`
[INFO] [stdout]   --> src/tensor/layout/tiled_view.rs:95:43
[INFO] [stdout]    |
[INFO] [stdout] 95 |         let in_bounds = self.is_in_bounds(pos.clone());
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 95 |         let in_bounds = self.is_in_bounds(<cubecl_core::frontend::SequenceExpand<u32> as Into<_>>::into(pos.clone()));
[INFO] [stdout]    |                                           ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::SequenceExpand<u32>`
[INFO] [stdout]   --> src/tensor/layout/tiled_view.rs:94:37
[INFO] [stdout]    |
[INFO] [stdout] 94 |     fn to_source_pos_checked(&self, pos: Self::Coordinates) -> (Self::SourceCoordinates, bool) {
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 94 |     fn to_source_pos_checked(&self, <cubecl_core::frontend::SequenceExpand<u32> as Into<_>>::into(pos): Self::Coordinates) -> (Self::SourceCoordinates, bool) {
[INFO] [stdout]    |                                     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<u32>`
[INFO] [stdout]    --> src/tensor/layout/tiled_view.rs:116:21
[INFO] [stdout]     |
[INFO] [stdout] 116 |             let mut extent = 1u32;
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 116 |             let mut <cubecl_core::frontend::NativeExpand<u32> as Into<_>>::into(extent) = 1u32;
[INFO] [stdout]     |                     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::SequenceExpand<u32>`
[INFO] [stdout]    --> src/tensor/layout/tiled_view.rs:164:13
[INFO] [stdout]     |
[INFO] [stdout] 164 |             self.physical_shape.clone(),
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 164 |             <cubecl_core::frontend::SequenceExpand<u32> as Into<_>>::into(self.physical_shape.clone()),
[INFO] [stdout]     |             ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++                           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]    --> src/tensor/layout/tiled_view.rs:162:22
[INFO] [stdout]     |
[INFO] [stdout] 162 |       fn to_source_pos(&self, pos: Self::Coordinates) -> Self::SourceCoordinates {
[INFO] [stdout]     |  ______________________^
[INFO] [stdout] 163 | |         let split = TiledLayout::new(
[INFO] [stdout] 164 | |             self.physical_shape.clone(),
[INFO] [stdout] 165 | |             self.start_axis,
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 162 ~     fn to_source_pos(<usize as Into<_>>::into(&self, pos: Self::Coordinates) -> Self::SourceCoordinates {
[INFO] [stdout] 163 |         let split = TiledLayout::new(
[INFO] [stdout] 164 |             self.physical_shape.clone(),
[INFO] [stdout] 165 ~             self.start_axis),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]    --> src/tensor/layout/tiled_view.rs:162:22
[INFO] [stdout]     |
[INFO] [stdout] 162 |       fn to_source_pos(&self, pos: Self::Coordinates) -> Self::SourceCoordinates {
[INFO] [stdout]     |  ______________________^
[INFO] [stdout] 163 | |         let split = TiledLayout::new(
[INFO] [stdout] 164 | |             self.physical_shape.clone(),
[INFO] [stdout] 165 | |             self.start_axis,
[INFO] [stdout] 166 | |             self.num_tiled,
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 162 ~     fn to_source_pos(<usize as Into<_>>::into(&self, pos: Self::Coordinates) -> Self::SourceCoordinates {
[INFO] [stdout] 163 |         let split = TiledLayout::new(
[INFO] [stdout] 164 |             self.physical_shape.clone(),
[INFO] [stdout] 165 |             self.start_axis,
[INFO] [stdout] 166 ~             self.num_tiled),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]    --> src/tensor/layout/tiled_view.rs:162:22
[INFO] [stdout]     |
[INFO] [stdout] 162 |       fn to_source_pos(&self, pos: Self::Coordinates) -> Self::SourceCoordinates {
[INFO] [stdout]     |  ______________________^
[INFO] [stdout] 163 | |         let split = TiledLayout::new(
[INFO] [stdout] 164 | |             self.physical_shape.clone(),
[INFO] [stdout] 165 | |             self.start_axis,
[INFO] [stdout] 166 | |             self.num_tiled,
[INFO] [stdout] 167 | |             self.levels,
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 162 ~     fn to_source_pos(<usize as Into<_>>::into(&self, pos: Self::Coordinates) -> Self::SourceCoordinates {
[INFO] [stdout] 163 |         let split = TiledLayout::new(
[INFO] [stdout] ...
[INFO] [stdout] 166 |             self.num_tiled,
[INFO] [stdout] 167 ~             self.levels),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::SequenceExpand<u32>`
[INFO] [stdout]    --> src/tensor/layout/tiled_view.rs:162:29
[INFO] [stdout]     |
[INFO] [stdout] 162 |     fn to_source_pos(&self, pos: Self::Coordinates) -> Self::SourceCoordinates {
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 162 |     fn to_source_pos(&self, <cubecl_core::frontend::SequenceExpand<u32> as Into<_>>::into(pos): Self::Coordinates) -> Self::SourceCoordinates {
[INFO] [stdout]     |                             ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::SequenceExpand<u32>`
[INFO] [stdout]    --> src/tensor/layout/tiled_view.rs:180:43
[INFO] [stdout]     |
[INFO] [stdout] 180 |         let in_bounds = self.is_in_bounds(pos.clone());
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 180 |         let in_bounds = self.is_in_bounds(<cubecl_core::frontend::SequenceExpand<u32> as Into<_>>::into(pos.clone()));
[INFO] [stdout]     |                                           ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::SequenceExpand<u32>`
[INFO] [stdout]    --> src/tensor/layout/tiled_view.rs:179:37
[INFO] [stdout]     |
[INFO] [stdout] 179 |     fn to_source_pos_checked(&self, pos: Self::Coordinates) -> (Self::SourceCoordinates, bool) {
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 179 |     fn to_source_pos_checked(&self, <cubecl_core::frontend::SequenceExpand<u32> as Into<_>>::into(pos): Self::Coordinates) -> (Self::SourceCoordinates, bool) {
[INFO] [stdout]     |                                     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::SequenceExpand<u32>`
[INFO] [stdout]    --> src/tensor/layout/tiled_view.rs:186:13
[INFO] [stdout]     |
[INFO] [stdout] 186 |             self.physical_shape.clone(),
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 186 |             <cubecl_core::frontend::SequenceExpand<u32> as Into<_>>::into(self.physical_shape.clone()),
[INFO] [stdout]     |             ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++                           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]    --> src/tensor/layout/tiled_view.rs:184:14
[INFO] [stdout]     |
[INFO] [stdout] 184 |       fn shape(&self) -> Self::Coordinates {
[INFO] [stdout]     |  ______________^
[INFO] [stdout] 185 | |         let split = TiledLayout::new(
[INFO] [stdout] 186 | |             self.physical_shape.clone(),
[INFO] [stdout] 187 | |             self.start_axis,
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 184 ~     fn shape(<usize as Into<_>>::into(&self) -> Self::Coordinates {
[INFO] [stdout] 185 |         let split = TiledLayout::new(
[INFO] [stdout] 186 |             self.physical_shape.clone(),
[INFO] [stdout] 187 ~             self.start_axis),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]    --> src/tensor/layout/tiled_view.rs:184:14
[INFO] [stdout]     |
[INFO] [stdout] 184 |       fn shape(&self) -> Self::Coordinates {
[INFO] [stdout]     |  ______________^
[INFO] [stdout] 185 | |         let split = TiledLayout::new(
[INFO] [stdout] 186 | |             self.physical_shape.clone(),
[INFO] [stdout] 187 | |             self.start_axis,
[INFO] [stdout] 188 | |             self.num_tiled,
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 184 ~     fn shape(<usize as Into<_>>::into(&self) -> Self::Coordinates {
[INFO] [stdout] 185 |         let split = TiledLayout::new(
[INFO] [stdout] 186 |             self.physical_shape.clone(),
[INFO] [stdout] 187 |             self.start_axis,
[INFO] [stdout] 188 ~             self.num_tiled),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]    --> src/tensor/layout/tiled_view.rs:184:14
[INFO] [stdout]     |
[INFO] [stdout] 184 |       fn shape(&self) -> Self::Coordinates {
[INFO] [stdout]     |  ______________^
[INFO] [stdout] 185 | |         let split = TiledLayout::new(
[INFO] [stdout] 186 | |             self.physical_shape.clone(),
[INFO] [stdout] 187 | |             self.start_axis,
[INFO] [stdout] 188 | |             self.num_tiled,
[INFO] [stdout] 189 | |             self.levels,
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 184 ~     fn shape(<usize as Into<_>>::into(&self) -> Self::Coordinates {
[INFO] [stdout] 185 |         let split = TiledLayout::new(
[INFO] [stdout] ...
[INFO] [stdout] 188 |             self.num_tiled,
[INFO] [stdout] 189 ~             self.levels),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<<L as Layout>::Coordinates as CubeType>::ExpandType`
[INFO] [stdout]    --> src/tensor/view/launch.rs:257:33
[INFO] [stdout]     |
[INFO] [stdout] 257 |         fn to_source_pos(&self, pos: Self::Coordinates) -> Self::SourceCoordinates {
[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: the full name for the type has been written to '/opt/rustwide/target/debug/build/cubecl-std/951faf6648960f40/out/cubecl_std-951faf6648960f40.long-type-15912098227834820249.txt'
[INFO] [stdout]     = note: consider using `--verbose` to print the full type name to the console
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 257 |         fn to_source_pos(&self, <<<L as tensor::layout::base::Layout>::Coordinates as cubecl_core::frontend::CubeType>::ExpandType as Into<_>>::into(pos): Self::Coordinates) -> Self::SourceCoordinates {
[INFO] [stdout]     |                                 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<<L as Layout>::Coordinates as CubeType>::ExpandType`
[INFO] [stdout]    --> src/tensor/view/launch.rs:261:41
[INFO] [stdout]     |
[INFO] [stdout] 261 |         fn to_source_pos_checked(&self, pos: Self::Coordinates) -> (Self::SourceCoordinates, bool) {
[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: the full name for the type has been written to '/opt/rustwide/target/debug/build/cubecl-std/951faf6648960f40/out/cubecl_std-951faf6648960f40.long-type-15912098227834820249.txt'
[INFO] [stdout]     = note: consider using `--verbose` to print the full type name to the console
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 261 |         fn to_source_pos_checked(&self, <<<L as tensor::layout::base::Layout>::Coordinates as cubecl_core::frontend::CubeType>::ExpandType as Into<_>>::into(pos): Self::Coordinates) -> (Self::SourceCoordinates, bool) {
[INFO] [stdout]     |                                         +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<<L as Layout>::Coordinates as CubeType>::ExpandType`
[INFO] [stdout]    --> src/tensor/view/launch.rs:269:32
[INFO] [stdout]     |
[INFO] [stdout] 269 |         fn is_in_bounds(&self, pos: Self::Coordinates) -> bool {
[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: the full name for the type has been written to '/opt/rustwide/target/debug/build/cubecl-std/951faf6648960f40/out/cubecl_std-951faf6648960f40.long-type-15912098227834820249.txt'
[INFO] [stdout]     = note: consider using `--verbose` to print the full type name to the console
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 269 |         fn is_in_bounds(&self, <<<L as tensor::layout::base::Layout>::Coordinates as cubecl_core::frontend::CubeType>::ExpandType as Into<_>>::into(pos): Self::Coordinates) -> bool {
[INFO] [stdout]     |                                +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<usize>`
[INFO] [stdout]    --> src/tensor/virtual.rs:106:23
[INFO] [stdout]     |
[INFO] [stdout] 106 |         self.slice(0, self.len())
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 106 |         self.slice(0, <cubecl_core::frontend::NativeExpand<usize> as Into<_>>::into(self.len()))
[INFO] [stdout]     |                       ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++          +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<usize>`
[INFO] [stdout]    --> src/tensor/virtual.rs:110:27
[INFO] [stdout]     |
[INFO] [stdout] 110 |         self.slice_mut(0, self.len())
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 110 |         self.slice_mut(0, <cubecl_core::frontend::NativeExpand<usize> as Into<_>>::into(self.len()))
[INFO] [stdout]     |                           ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++          +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&tensor::r#virtual::VirtualTensorExpand<E, N, IO>`
[INFO] [stdout]    --> src/tensor/virtual.rs:165:20
[INFO] [stdout]     |
[INFO] [stdout] 165 |     pub fn as_view(&self) -> View<'_, Vector<E, N>, usize> {
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 165 |     pub fn as_view(<&tensor::r#virtual::VirtualTensorExpand<E, N, IO> as Into<_>>::into(&self)) -> View<'_, Vector<E, N>, usize> {
[INFO] [stdout]     |                    +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]    --> src/tensor/virtual.rs:166:13
[INFO] [stdout]     |
[INFO] [stdout] 166 |         let vector_size = self.vector_size();
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 166 |         let <usize as Into<_>>::into(vector_size) = self.vector_size();
[INFO] [stdout]     |             +++++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]    --> src/tensor/virtual.rs:241:13
[INFO] [stdout]     |
[INFO] [stdout] 241 |         let vector_size = self.vector_size();
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 241 |         let <usize as Into<_>>::into(vector_size) = self.vector_size();
[INFO] [stdout]     |             +++++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&mut tensor::r#virtual::VirtualTensorExpand<E, N, cubecl_core::frontend::ReadWrite>`
[INFO] [stdout]    --> src/tensor/virtual.rs:240:24
[INFO] [stdout]     |
[INFO] [stdout] 240 |     pub fn as_view_mut(&mut self) -> ViewMut<'_, Vector<E, N>, usize> {
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 240 |     pub fn as_view_mut(<&mut tensor::r#virtual::VirtualTensorExpand<E, N, cubecl_core::frontend::ReadWrite> as Into<_>>::into(&mut self)) -> ViewMut<'_, Vector<E, N>, usize> {
[INFO] [stdout]     |                        +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++         +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<usize>`
[INFO] [stdout]    --> src/tensor/virtual.rs:249:44
[INFO] [stdout]     |
[INFO] [stdout] 249 |     pub fn coordinate(&self, index: usize, dim: usize) -> usize {
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 249 |     pub fn coordinate(&self, index: usize, <cubecl_core::frontend::NativeExpand<usize> as Into<_>>::into(dim): usize) -> usize {
[INFO] [stdout]     |                                            ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `MatrixIdent`
[INFO] [stdout]   --> src/throughput/runners/compute_cmma.rs:62:9
[INFO] [stdout]    |
[INFO] [stdout] 62 |         cmma::MatrixIdent::A,
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 62 |         <MatrixIdent as Into<_>>::into(cmma::MatrixIdent::A),
[INFO] [stdout]    |         +++++++++++++++++++++++++++++++                    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]   --> src/throughput/runners/compute_cmma.rs:59:20
[INFO] [stdout]    |
[INFO] [stdout] 59 |     let CmmaDims { m, n, k } = cmm_dims;
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 59 |     let CmmaDims { <usize as Into<_>>::into(m), n, k } = cmm_dims;
[INFO] [stdout]    |                    +++++++++++++++++++++++++ +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]   --> src/throughput/runners/compute_cmma.rs:59:23
[INFO] [stdout]    |
[INFO] [stdout] 59 |     let CmmaDims { m, n, k } = cmm_dims;
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 59 |     let CmmaDims { m, <usize as Into<_>>::into(n), k } = cmm_dims;
[INFO] [stdout]    |                       +++++++++++++++++++++++++ +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]   --> src/throughput/runners/compute_cmma.rs:59:26
[INFO] [stdout]    |
[INFO] [stdout] 59 |     let CmmaDims { m, n, k } = cmm_dims;
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 59 |     let CmmaDims { m, n, <usize as Into<_>>::into(k) } = cmm_dims;
[INFO] [stdout]    |                          +++++++++++++++++++++++++ +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `MatrixLayout`
[INFO] [stdout]   --> src/throughput/runners/compute_cmma.rs:66:9
[INFO] [stdout]    |
[INFO] [stdout] 66 |         cmma::MatrixLayout::RowMajor,
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 66 |         <MatrixLayout as Into<_>>::into(cmma::MatrixLayout::RowMajor),
[INFO] [stdout]    |         ++++++++++++++++++++++++++++++++                            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<I>`
[INFO] [stdout]   --> src/throughput/runners/compute_cmma.rs:67:9
[INFO] [stdout]    |
[INFO] [stdout] 67 |         I::cast_from(1),
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 67 |         <cubecl_core::frontend::NativeExpand<I> as Into<_>>::into(I::cast_from(1)),
[INFO] [stdout]    |         ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++               +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `MatrixIdent`
[INFO] [stdout]   --> src/throughput/runners/compute_cmma.rs:71:9
[INFO] [stdout]    |
[INFO] [stdout] 71 |         cmma::MatrixIdent::B,
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 71 |         <MatrixIdent as Into<_>>::into(cmma::MatrixIdent::B),
[INFO] [stdout]    |         +++++++++++++++++++++++++++++++                    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `MatrixLayout`
[INFO] [stdout]   --> src/throughput/runners/compute_cmma.rs:75:9
[INFO] [stdout]    |
[INFO] [stdout] 75 |         cmma::MatrixLayout::ColMajor,
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 75 |         <MatrixLayout as Into<_>>::into(cmma::MatrixLayout::ColMajor),
[INFO] [stdout]    |         ++++++++++++++++++++++++++++++++                            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<I>`
[INFO] [stdout]   --> src/throughput/runners/compute_cmma.rs:76:9
[INFO] [stdout]    |
[INFO] [stdout] 76 |         I::cast_from(1),
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 76 |         <cubecl_core::frontend::NativeExpand<I> as Into<_>>::into(I::cast_from(1)),
[INFO] [stdout]    |         ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++               +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `MatrixIdent`
[INFO] [stdout]   --> src/throughput/runners/compute_cmma.rs:80:9
[INFO] [stdout]    |
[INFO] [stdout] 80 |         cmma::MatrixIdent::Accumulator,
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 80 |         <MatrixIdent as Into<_>>::into(cmma::MatrixIdent::Accumulator),
[INFO] [stdout]    |         +++++++++++++++++++++++++++++++                              +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `MatrixLayout`
[INFO] [stdout]   --> src/throughput/runners/compute_cmma.rs:84:9
[INFO] [stdout]    |
[INFO] [stdout] 84 |         cmma::MatrixLayout::Undefined,
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 84 |         <MatrixLayout as Into<_>>::into(cmma::MatrixLayout::Undefined),
[INFO] [stdout]    |         ++++++++++++++++++++++++++++++++                             +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<ACC>`
[INFO] [stdout]   --> src/throughput/runners/compute_cmma.rs:85:9
[INFO] [stdout]    |
[INFO] [stdout] 85 |         ACC::cast_from(0.0),
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 85 |         <cubecl_core::frontend::NativeExpand<ACC> as Into<_>>::into(ACC::cast_from(0.0)),
[INFO] [stdout]    |         ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++                   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&mut cubecl_core::frontend::NativeExpand<[cubecl_core::frontend::Vector<ACC, N>]>`
[INFO] [stdout]   --> src/throughput/runners/compute_cmma.rs:53:5
[INFO] [stdout]    |
[INFO] [stdout] 53 |     output: &mut [Vector<ACC, N>],
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 53 |     <&mut cubecl_core::frontend::NativeExpand<[cubecl_core::frontend::Vector<ACC, N>]> as Into<_>>::into(output): &mut [Vector<ACC, N>],
[INFO] [stdout]    |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `MatrixLayout`
[INFO] [stdout]   --> src/throughput/runners/compute_cmma.rs:93:45
[INFO] [stdout]    |
[INFO] [stdout] 93 |         cmma::store(output, &acc, n as u32, cmma::MatrixLayout::RowMajor);
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 93 |         cmma::store(output, &acc, n as u32, <MatrixLayout as Into<_>>::into(cmma::MatrixLayout::RowMajor));
[INFO] [stdout]    |                                             ++++++++++++++++++++++++++++++++                            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]   --> src/throughput/runners/compute_direct.rs:73:9
[INFO] [stdout]    |
[INFO] [stdout] 73 |     for lane in 0..lanes {
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 73 |     for <usize as Into<_>>::into(lane) in 0..lanes {
[INFO] [stdout]    |         +++++++++++++++++++++++++    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<cubecl_core::frontend::Vector<I, N>>`
[INFO] [stdout]   --> src/throughput/runners/compute_direct.rs:65:13
[INFO] [stdout]    |
[INFO] [stdout] 65 |     let mut s0 = Vector::<I, N>::empty();
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 65 |     let mut <cubecl_core::frontend::NativeExpand<cubecl_core::frontend::Vector<I, N>> as Into<_>>::into(s0) = Vector::<I, N>::empty();
[INFO] [stdout]    |             ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<cubecl_core::frontend::Vector<I, N>>`
[INFO] [stdout]   --> src/throughput/runners/compute_direct.rs:62:13
[INFO] [stdout]    |
[INFO] [stdout] 62 |     let mut b = Vector::<I, N>::empty();
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 62 |     let mut <cubecl_core::frontend::NativeExpand<cubecl_core::frontend::Vector<I, N>> as Into<_>>::into(b) = Vector::<I, N>::empty();
[INFO] [stdout]    |             ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<cubecl_core::frontend::Vector<I, N>>`
[INFO] [stdout]   --> src/throughput/runners/compute_direct.rs:63:13
[INFO] [stdout]    |
[INFO] [stdout] 63 |     let mut c = Vector::<I, N>::empty();
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 63 |     let mut <cubecl_core::frontend::NativeExpand<cubecl_core::frontend::Vector<I, N>> as Into<_>>::into(c) = Vector::<I, N>::empty();
[INFO] [stdout]    |             ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]   --> src/throughput/runners/compute_direct.rs:57:17
[INFO] [stdout]    |
[INFO] [stdout] 57 |     #[comptime] use_fma: bool,
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 57 |     #[comptime] <bool as Into<_>>::into(use_fma): bool,
[INFO] [stdout]    |                 ++++++++++++++++++++++++       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<cubecl_core::frontend::Vector<I, N>>`
[INFO] [stdout]   --> src/throughput/runners/compute_direct.rs:66:13
[INFO] [stdout]    |
[INFO] [stdout] 66 |     let mut s1 = Vector::<I, N>::empty();
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 66 |     let mut <cubecl_core::frontend::NativeExpand<cubecl_core::frontend::Vector<I, N>> as Into<_>>::into(s1) = Vector::<I, N>::empty();
[INFO] [stdout]    |             ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<cubecl_core::frontend::Vector<I, N>>`
[INFO] [stdout]   --> src/throughput/runners/compute_direct.rs:67:13
[INFO] [stdout]    |
[INFO] [stdout] 67 |     let mut s2 = Vector::<I, N>::empty();
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 67 |     let mut <cubecl_core::frontend::NativeExpand<cubecl_core::frontend::Vector<I, N>> as Into<_>>::into(s2) = Vector::<I, N>::empty();
[INFO] [stdout]    |             ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<cubecl_core::frontend::Vector<I, N>>`
[INFO] [stdout]   --> src/throughput/runners/compute_direct.rs:68:13
[INFO] [stdout]    |
[INFO] [stdout] 68 |     let mut s3 = Vector::<I, N>::empty();
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 68 |     let mut <cubecl_core::frontend::NativeExpand<cubecl_core::frontend::Vector<I, N>> as Into<_>>::into(s3) = Vector::<I, N>::empty();
[INFO] [stdout]    |             ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<cubecl_core::frontend::Vector<I, N>>`
[INFO] [stdout]    --> src/throughput/runners/compute_direct.rs:102:5
[INFO] [stdout]     |
[INFO] [stdout] 102 |     s: Vector<I, N>,
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 102 |     <cubecl_core::frontend::NativeExpand<cubecl_core::frontend::Vector<I, N>> as Into<_>>::into(s): Vector<I, N>,
[INFO] [stdout]     |     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<cubecl_core::frontend::Vector<I, N>>`
[INFO] [stdout]    --> src/throughput/runners/compute_direct.rs:103:5
[INFO] [stdout]     |
[INFO] [stdout] 103 |     b: Vector<I, N>,
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 103 |     <cubecl_core::frontend::NativeExpand<cubecl_core::frontend::Vector<I, N>> as Into<_>>::into(b): Vector<I, N>,
[INFO] [stdout]     |     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<cubecl_core::frontend::Vector<I, N>>`
[INFO] [stdout]    --> src/throughput/runners/compute_direct.rs:104:5
[INFO] [stdout]     |
[INFO] [stdout] 104 |     c: Vector<I, N>,
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 104 |     <cubecl_core::frontend::NativeExpand<cubecl_core::frontend::Vector<I, N>> as Into<_>>::into(c): Vector<I, N>,
[INFO] [stdout]     |     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<usize>`
[INFO] [stdout]   --> src/throughput/runners/memory_direct.rs:71:9
[INFO] [stdout]    |
[INFO] [stdout] 71 |     let stride = CUBE_DIM as usize * CUBE_COUNT;
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 71 |     let <cubecl_core::frontend::NativeExpand<usize> as Into<_>>::into(stride) = CUBE_DIM as usize * CUBE_COUNT;
[INFO] [stdout]    |         ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<usize>`
[INFO] [stdout]    --> src/throughput/runners/memory_probe.rs:222:9
[INFO] [stdout]     |
[INFO] [stdout] 222 |     let stride = CUBE_DIM as usize * CUBE_COUNT;
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 222 |     let <cubecl_core::frontend::NativeExpand<usize> as Into<_>>::into(stride) = CUBE_DIM as usize * CUBE_COUNT;
[INFO] [stdout]     |         ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<usize>`
[INFO] [stdout]   --> src/throughput/runners/memory_read.rs:84:9
[INFO] [stdout]    |
[INFO] [stdout] 84 |     let stride = CUBE_DIM as usize * CUBE_COUNT;
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 84 |     let <cubecl_core::frontend::NativeExpand<usize> as Into<_>>::into(stride) = CUBE_DIM as usize * CUBE_COUNT;
[INFO] [stdout]    |         ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]   --> src/throughput/runners/memory_read.rs:97:9
[INFO] [stdout]    |
[INFO] [stdout] 97 |     for lane in 0..lanes {
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 97 |     for <usize as Into<_>>::into(lane) in 0..lanes {
[INFO] [stdout]    |         +++++++++++++++++++++++++    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<I>`
[INFO] [stdout]   --> src/throughput/runners/memory_read.rs:98:26
[INFO] [stdout]    |
[INFO] [stdout] 98 |         acc.insert(lane, I::cast_from(0));
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 98 |         acc.insert(lane, <cubecl_core::frontend::NativeExpand<I> as Into<_>>::into(I::cast_from(0)));
[INFO] [stdout]    |                          ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++               +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<usize>`
[INFO] [stdout]   --> src/throughput/runners/memory_write.rs:77:9
[INFO] [stdout]    |
[INFO] [stdout] 77 |     let stride = CUBE_DIM as usize * CUBE_COUNT;
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 77 |     let <cubecl_core::frontend::NativeExpand<usize> as Into<_>>::into(stride) = CUBE_DIM as usize * CUBE_COUNT;
[INFO] [stdout]    |         ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<usize>`
[INFO] [stdout]   --> src/throughput/runners/memory_write.rs:72:5
[INFO] [stdout]    |
[INFO] [stdout] 72 |     n_iter: usize,
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 72 |     <cubecl_core::frontend::NativeExpand<usize> as Into<_>>::into(n_iter): usize,
[INFO] [stdout]    |     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]   --> src/throughput/runners/memory_write.rs:93:9
[INFO] [stdout]    |
[INFO] [stdout] 93 |     for lane in 0..lanes {
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 93 |     for <usize as Into<_>>::into(lane) in 0..lanes {
[INFO] [stdout]    |         +++++++++++++++++++++++++    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<I>`
[INFO] [stdout]   --> src/fast_math.rs:44:23
[INFO] [stdout]    |
[INFO] [stdout] 44 |     pub fn div(&self, dividend: I) -> I {
[INFO] [stdout]    |                       ^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: `#[deny(self_type_conversion)]` on by default
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 44 |     pub fn div(&self, <cubecl_core::frontend::NativeExpand<I> as Into<_>>::into(dividend): I) -> I {
[INFO] [stdout]    |                       ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<I>`
[INFO] [stdout]   --> src/fast_math.rs:58:26
[INFO] [stdout]    |
[INFO] [stdout] 58 |     pub fn modulo(&self, dividend: I) -> I {
[INFO] [stdout]    |                          ^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 58 |     pub fn modulo(&self, <cubecl_core::frontend::NativeExpand<I> as Into<_>>::into(dividend): I) -> I {
[INFO] [stdout]    |                          ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<I>`
[INFO] [stdout]   --> src/fast_math.rs:66:27
[INFO] [stdout]    |
[INFO] [stdout] 66 |     pub fn div_mod(&self, dividend: I) -> (I, I) {
[INFO] [stdout]    |                           ^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 66 |     pub fn div_mod(&self, <cubecl_core::frontend::NativeExpand<I> as Into<_>>::into(dividend): I) -> (I, I) {
[INFO] [stdout]    |                           ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]   --> src/reinterpret_slice.rs:72:25
[INFO] [stdout]    |
[INFO] [stdout] 72 |                     for j in 0..self.vector_size {
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 72 |                     for <usize as Into<_>>::into(j) in 0..self.vector_size {
[INFO] [stdout]    |                         +++++++++++++++++++++++++ +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<<S as cubecl_core::frontend::CubePrimitive>::Scalar>`
[INFO] [stdout]   --> src/reinterpret_slice.rs:73:76
[INFO] [stdout]    |
[INFO] [stdout] 73 |                         vector.insert(comptime!(k * self.vector_size + j), elem.extract(j));
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 73 |                         vector.insert(comptime!(k * self.vector_size + j), <cubecl_core::frontend::NativeExpand<<S as cubecl_core::frontend::CubePrimitive>::Scalar> as Into<_>>::into(elem.extract(j)));
[INFO] [stdout]    |                                                                            ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++               +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `NativeExpand<Vector<<S as CubePrimitive>::Scalar, DynamicSize<__N2>>>`
[INFO] [stdout]   --> src/reinterpret_slice.rs:67:25
[INFO] [stdout]    |
[INFO] [stdout] 67 |                 let mut vector = Vector::<S::Scalar, N2>::empty();
[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: the full name for the type has been written to '/opt/rustwide/target/debug/build/cubecl-std/8508089d34faaf71/out/cubecl_std-8508089d34faaf71.long-type-13030423884825824464.txt'
[INFO] [stdout]    = note: consider using `--verbose` to print the full type name to the console
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 67 |                 let mut <cubecl_core::frontend::NativeExpand<cubecl_core::frontend::Vector<<S as cubecl_core::frontend::CubePrimitive>::Scalar, DynamicSize<ReinterpretSliceExpand<'a, S, T>::__expand_read_method::__N2>>> as Into<_>>::into(vector) = Vector::<S::Scalar, N2>::empty();
[INFO] [stdout]    |                         ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]    --> src/reinterpret_slice.rs:148:25
[INFO] [stdout]     |
[INFO] [stdout] 148 |                     for j in 0..self.vector_size {
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 148 |                     for <usize as Into<_>>::into(j) in 0..self.vector_size {
[INFO] [stdout]     |                         +++++++++++++++++++++++++ +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<<S as cubecl_core::frontend::CubePrimitive>::Scalar>`
[INFO] [stdout]    --> src/reinterpret_slice.rs:149:76
[INFO] [stdout]     |
[INFO] [stdout] 149 |                         vector.insert(comptime!(k * self.vector_size + j), elem.extract(j));
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 149 |                         vector.insert(comptime!(k * self.vector_size + j), <cubecl_core::frontend::NativeExpand<<S as cubecl_core::frontend::CubePrimitive>::Scalar> as Into<_>>::into(elem.extract(j)));
[INFO] [stdout]     |                                                                            ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++               +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `NativeExpand<Vector<<S as CubePrimitive>::Scalar, DynamicSize<__N2>>>`
[INFO] [stdout]    --> src/reinterpret_slice.rs:143:25
[INFO] [stdout]     |
[INFO] [stdout] 143 |                 let mut vector = Vector::<S::Scalar, N2>::empty();
[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: the full name for the type has been written to '/opt/rustwide/target/debug/build/cubecl-std/8508089d34faaf71/out/cubecl_std-8508089d34faaf71.long-type-8287901459986803591.txt'
[INFO] [stdout]     = note: consider using `--verbose` to print the full type name to the console
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 143 |                 let mut <cubecl_core::frontend::NativeExpand<cubecl_core::frontend::Vector<<S as cubecl_core::frontend::CubePrimitive>::Scalar, DynamicSize<ReinterpretSliceMutExpand<'a, S, T>::__expand_read_method::__N2>>> as Into<_>>::into(vector) = Vector::<S::Scalar, N2>::empty();
[INFO] [stdout]     |                         +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<T>`
[INFO] [stdout]    --> src/reinterpret_slice.rs:158:43
[INFO] [stdout]     |
[INFO] [stdout] 158 |     pub fn write(&mut self, index: usize, value: T) {
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 158 |     pub fn write(&mut self, index: usize, <cubecl_core::frontend::NativeExpand<T> as Into<_>>::into(value): T) {
[INFO] [stdout]     |                                           ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]    --> src/reinterpret_slice.rs:173:25
[INFO] [stdout]     |
[INFO] [stdout] 173 |                     for j in 0..vector_size {
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 173 |                     for <usize as Into<_>>::into(j) in 0..vector_size {
[INFO] [stdout]     |                         +++++++++++++++++++++++++ +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<<S as cubecl_core::frontend::CubePrimitive>::Scalar>`
[INFO] [stdout]    --> src/reinterpret_slice.rs:174:42
[INFO] [stdout]     |
[INFO] [stdout] 174 |                         vector.insert(j, reinterpreted.extract(k * vector_size + j));
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 174 |                         vector.insert(j, <cubecl_core::frontend::NativeExpand<<S as cubecl_core::frontend::CubePrimitive>::Scalar> as Into<_>>::into(reinterpreted.extract(k * vector_size + j)));
[INFO] [stdout]     |                                          ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++                                          +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `NativeExpand<Vector<<S as CubePrimitive>::Scalar, DynamicSize<__N1>>>`
[INFO] [stdout]    --> src/reinterpret_slice.rs:162:13
[INFO] [stdout]     |
[INFO] [stdout] 162 |         let reinterpreted = Vector::<S::Scalar, N1>::reinterpret(value);
[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: the full name for the type has been written to '/opt/rustwide/target/debug/build/cubecl-std/8508089d34faaf71/out/cubecl_std-8508089d34faaf71.long-type-8784430502740533123.txt'
[INFO] [stdout]     = note: consider using `--verbose` to print the full type name to the console
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 162 |         let <cubecl_core::frontend::NativeExpand<cubecl_core::frontend::Vector<<S as cubecl_core::frontend::CubePrimitive>::Scalar, DynamicSize<ReinterpretSliceMutExpand<'a, S, T>::__expand_write_method::__N1>>> as Into<_>>::into(reinterpreted) = Vector::<S::Scalar, N1>::reinterpret(value);
[INFO] [stdout]     |             ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++             +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<u32>`
[INFO] [stdout]   --> src/swizzle.rs:88:17
[INFO] [stdout]    |
[INFO] [stdout] 88 |             let offset_masked = offset_bytes & self.yyy_mask;
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 88 |             let <cubecl_core::frontend::NativeExpand<u32> as Into<_>>::into(offset_masked) = offset_bytes & self.yyy_mask;
[INFO] [stdout]    |                 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++             +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<cubecl_core::frontend::Vector<Q, NQ>>`
[INFO] [stdout]   --> src/quant/dequantize.rs:17:5
[INFO] [stdout]    |
[INFO] [stdout] 17 |     value: Vector<Q, NQ>,
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 17 |     <cubecl_core::frontend::NativeExpand<cubecl_core::frontend::Vector<Q, NQ>> as Into<_>>::into(value): Vector<Q, NQ>,
[INFO] [stdout]    |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<cubecl_core::frontend::Vector<u32, NQ>>`
[INFO] [stdout]   --> src/quant/dequantize.rs:27:42
[INFO] [stdout]    |
[INFO] [stdout] 27 |             unpack_cast_u32::<F, NQ, NF>(Vector::cast_from(value), table.clone(), scheme)
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 27 |             unpack_cast_u32::<F, NQ, NF>(<cubecl_core::frontend::NativeExpand<cubecl_core::frontend::Vector<u32, NQ>> as Into<_>>::into(Vector::cast_from(value)), table.clone(), scheme)
[INFO] [stdout]    |                                          +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++                        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::ComptimeOptionExpand<Box<[f32]>>`
[INFO] [stdout]   --> src/quant/dequantize.rs:27:68
[INFO] [stdout]    |
[INFO] [stdout] 27 |             unpack_cast_u32::<F, NQ, NF>(Vector::cast_from(value), table.clone(), scheme)
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 27 |             unpack_cast_u32::<F, NQ, NF>(Vector::cast_from(value), <cubecl_core::frontend::ComptimeOptionExpand<Box<[f32]>> as Into<_>>::into(table.clone()), scheme)
[INFO] [stdout]    |                                                                    +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++             +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::quant::scheme::QuantScheme`
[INFO] [stdout]   --> src/quant/dequantize.rs:20:17
[INFO] [stdout]    |
[INFO] [stdout] 20 |     #[comptime] scheme: QuantScheme,
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 20 |     #[comptime] <cubecl_core::quant::scheme::QuantScheme as Into<_>>::into(scheme): QuantScheme,
[INFO] [stdout]    |                 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<S>`
[INFO] [stdout]   --> src/quant/dequantize.rs:18:5
[INFO] [stdout]    |
[INFO] [stdout] 18 |     scale: S,
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 18 |     <cubecl_core::frontend::NativeExpand<S> as Into<_>>::into(scale): S,
[INFO] [stdout]    |     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<cubecl_core::frontend::Vector<Q, NQ>>`
[INFO] [stdout]   --> src/quant/dequantize.rs:47:5
[INFO] [stdout]    |
[INFO] [stdout] 47 |     value: Vector<Q, NQ>,
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 47 |     <cubecl_core::frontend::NativeExpand<cubecl_core::frontend::Vector<Q, NQ>> as Into<_>>::into(value): Vector<Q, NQ>,
[INFO] [stdout]    |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<f32>`
[INFO] [stdout]   --> src/quant/dequantize.rs:48:5
[INFO] [stdout]    |
[INFO] [stdout] 48 |     scale: f32,
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 48 |     <cubecl_core::frontend::NativeExpand<f32> as Into<_>>::into(scale): f32,
[INFO] [stdout]    |     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::ComptimeOptionExpand<Box<[f32]>>`
[INFO] [stdout]   --> src/quant/dequantize.rs:49:5
[INFO] [stdout]    |
[INFO] [stdout] 49 |     table: ComptimeOption<Box<[f32]>>,
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 49 |     <cubecl_core::frontend::ComptimeOptionExpand<Box<[f32]>> as Into<_>>::into(table): ComptimeOption<Box<[f32]>>,
[INFO] [stdout]    |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::quant::scheme::QuantScheme`
[INFO] [stdout]   --> src/quant/dequantize.rs:50:17
[INFO] [stdout]    |
[INFO] [stdout] 50 |     #[comptime] scheme: QuantScheme,
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 50 |     #[comptime] <cubecl_core::quant::scheme::QuantScheme as Into<_>>::into(scheme): QuantScheme,
[INFO] [stdout]    |                 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<cubecl_core::frontend::Vector<f32, NF>>`
[INFO] [stdout]   --> src/quant/dequantize.rs:52:32
[INFO] [stdout]    |
[INFO] [stdout] 52 |       Vector::<F, NF>::cast_from(dequantize_aligned::<Q, f32, f32, NQ, NF>(
[INFO] [stdout]    |  ________________________________^
[INFO] [stdout] 53 | |         value, scale, table, scheme,
[INFO] [stdout] 54 | |     ))
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 52 ~     Vector::<F, NF>::cast_from(<cubecl_core::frontend::NativeExpand<cubecl_core::frontend::Vector<f32, NF>> as Into<_>>::into(dequantize_aligned::<Q, f32, f32, NQ, NF>(
[INFO] [stdout] 53 |         value, scale, table, scheme,
[INFO] [stdout] 54 ~     )))
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<S>`
[INFO] [stdout]   --> src/quant/dequantize.rs:63:67
[INFO] [stdout]    |
[INFO] [stdout] 63 | pub fn multiply_global_scale<S: CubePrimitive>(global_scale: f32, scale: S) -> f32 {
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 63 | pub fn multiply_global_scale<S: CubePrimitive>(global_scale: f32, <cubecl_core::frontend::NativeExpand<S> as Into<_>>::into(scale): S) -> f32 {
[INFO] [stdout]    |                                                                   ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]   --> src/quant/dequantize.rs:85:9
[INFO] [stdout]    |
[INFO] [stdout] 85 |     for vector_idx in 0..value.vector_size() {
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 85 |     for <usize as Into<_>>::into(vector_idx) in 0..value.vector_size() {
[INFO] [stdout]    |         +++++++++++++++++++++++++          +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<u32>`
[INFO] [stdout]   --> src/quant/dequantize.rs:91:17
[INFO] [stdout]    |
[INFO] [stdout] 91 |             let value = (packed_val >> shift as u32) & mask;
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 91 |             let <cubecl_core::frontend::NativeExpand<u32> as Into<_>>::into(value) = (packed_val >> shift as u32) & mask;
[INFO] [stdout]    |                 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::ComptimeOptionExpand<Box<[f32]>>`
[INFO] [stdout]   --> src/quant/dequantize.rs:93:59
[INFO] [stdout]    |
[INFO] [stdout] 93 |             let float_value = cast_masked::<F, NP>(value, table.clone(), scheme);
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 93 |             let float_value = cast_masked::<F, NP>(value, <cubecl_core::frontend::ComptimeOptionExpand<Box<[f32]>> as Into<_>>::into(table.clone()), scheme);
[INFO] [stdout]    |                                                           +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++             +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::quant::scheme::QuantScheme`
[INFO] [stdout]   --> src/quant/dequantize.rs:74:17
[INFO] [stdout]    |
[INFO] [stdout] 74 |     #[comptime] scheme: QuantScheme,
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 74 |     #[comptime] <cubecl_core::quant::scheme::QuantScheme as Into<_>>::into(scheme): QuantScheme,
[INFO] [stdout]    |                 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]   --> src/quant/dequantize.rs:97:21
[INFO] [stdout]    |
[INFO] [stdout] 97 |                 let out_offset = out_offset + packed_idx + native_idx;
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 97 |                 let <usize as Into<_>>::into(out_offset) = out_offset + packed_idx + native_idx;
[INFO] [stdout]    |                     +++++++++++++++++++++++++          +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]   --> src/quant/dequantize.rs:96:17
[INFO] [stdout]    |
[INFO] [stdout] 96 |             for native_idx in 0..native_packing {
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 96 |             for <usize as Into<_>>::into(native_idx) in 0..native_packing {
[INFO] [stdout]    |                 +++++++++++++++++++++++++          +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<F>`
[INFO] [stdout]   --> src/quant/dequantize.rs:98:40
[INFO] [stdout]    |
[INFO] [stdout] 98 |                 out.insert(out_offset, float_value.extract(native_idx));
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 98 |                 out.insert(out_offset, <cubecl_core::frontend::NativeExpand<F> as Into<_>>::into(float_value.extract(native_idx)));
[INFO] [stdout]    |                                        ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++                               +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<u32>`
[INFO] [stdout]    --> src/quant/dequantize.rs:134:13
[INFO] [stdout]     |
[INFO] [stdout] 134 |         let field = (word >> shift) & mask;
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 134 |         let <cubecl_core::frontend::NativeExpand<u32> as Into<_>>::into(field) = (word >> shift) & mask;
[INFO] [stdout]     |             ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::ComptimeOptionExpand<Box<[f32]>>`
[INFO] [stdout]    --> src/quant/dequantize.rs:135:49
[INFO] [stdout]     |
[INFO] [stdout] 135 |         let value = cast_masked::<F, N1>(field, table.clone(), scheme);
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 135 |         let value = cast_masked::<F, N1>(field, <cubecl_core::frontend::ComptimeOptionExpand<Box<[f32]>> as Into<_>>::into(table.clone()), scheme);
[INFO] [stdout]     |                                                 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++             +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::quant::scheme::QuantScheme`
[INFO] [stdout]    --> src/quant/dequantize.rs:120:17
[INFO] [stdout]     |
[INFO] [stdout] 120 |     #[comptime] scheme: QuantScheme,
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 120 |     #[comptime] <cubecl_core::quant::scheme::QuantScheme as Into<_>>::into(scheme): QuantScheme,
[INFO] [stdout]     |                 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]    --> src/quant/dequantize.rs:132:9
[INFO] [stdout]     |
[INFO] [stdout] 132 |     for j in 0..NF::value() {
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 132 |     for <usize as Into<_>>::into(j) in 0..NF::value() {
[INFO] [stdout]     |         +++++++++++++++++++++++++ +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]    --> src/quant/dequantize.rs:136:37
[INFO] [stdout]     |
[INFO] [stdout] 136 |         out.insert(j, value.extract(0usize));
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 136 |         out.insert(j, value.extract(<usize as Into<_>>::into(0usize)));
[INFO] [stdout]     |                                     +++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<F>`
[INFO] [stdout]    --> src/quant/dequantize.rs:136:23
[INFO] [stdout]     |
[INFO] [stdout] 136 |         out.insert(j, value.extract(0usize));
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 136 |         out.insert(j, <cubecl_core::frontend::NativeExpand<F> as Into<_>>::into(value.extract(0usize)));
[INFO] [stdout]     |                       ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++                     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<u32>`
[INFO] [stdout]    --> src/quant/dequantize.rs:163:5
[INFO] [stdout]     |
[INFO] [stdout] 163 |     value: 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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 163 |     <cubecl_core::frontend::NativeExpand<u32> as Into<_>>::into(value): u32,
[INFO] [stdout]     |     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::quant::scheme::QuantScheme`
[INFO] [stdout]    --> src/quant/dequantize.rs:165:17
[INFO] [stdout]     |
[INFO] [stdout] 165 |     #[comptime] scheme: QuantScheme,
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 165 |     #[comptime] <cubecl_core::quant::scheme::QuantScheme as Into<_>>::into(scheme): QuantScheme,
[INFO] [stdout]     |                 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<cubecl_core::e5m2>`
[INFO] [stdout]    --> src/quant/dequantize.rs:185:55
[INFO] [stdout]     |
[INFO] [stdout] 185 |         QuantValue::E5M2 => Vector::<F, N>::cast_from(e5m2::from_bits(value as 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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 185 |         QuantValue::E5M2 => Vector::<F, N>::cast_from(<cubecl_core::frontend::NativeExpand<cubecl_core::e5m2> as Into<_>>::into(e5m2::from_bits(value as u8))),
[INFO] [stdout]     |                                                       ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++                            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<cubecl_core::e4m3>`
[INFO] [stdout]    --> src/quant/dequantize.rs:186:55
[INFO] [stdout]     |
[INFO] [stdout] 186 |         QuantValue::E4M3 => Vector::<F, N>::cast_from(e4m3::from_bits(value as 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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 186 |         QuantValue::E4M3 => Vector::<F, N>::cast_from(<cubecl_core::frontend::NativeExpand<cubecl_core::e4m3> as Into<_>>::into(e4m3::from_bits(value as u8))),
[INFO] [stdout]     |                                                       ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++                            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<u32>`
[INFO] [stdout]    --> src/quant/dequantize.rs:180:5
[INFO] [stdout]     |
[INFO] [stdout] 180 |     value: 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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 180 |     <cubecl_core::frontend::NativeExpand<u32> as Into<_>>::into(value): u32,
[INFO] [stdout]     |     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<i32>`
[INFO] [stdout]    --> src/quant/dequantize.rs:200:17
[INFO] [stdout]     |
[INFO] [stdout] 200 |             let signed_value = (value ^ sign_bit) as i32 - sign_bit as i32;
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 200 |             let <cubecl_core::frontend::NativeExpand<i32> as Into<_>>::into(signed_value) = (value ^ sign_bit) as i32 - sign_bit as i32;
[INFO] [stdout]     |                 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<F>`
[INFO] [stdout]   --> src/quant/round.rs:18:36
[INFO] [stdout]    |
[INFO] [stdout] 18 | pub fn round_up_to_dtype<F: Float>(scale: F, #[comptime] dtype: ScaleDtype) -> F {
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 18 | pub fn round_up_to_dtype<F: Float>(<cubecl_core::frontend::NativeExpand<F> as Into<_>>::into(scale): F, #[comptime] dtype: ScaleDtype) -> F {
[INFO] [stdout]    |                                    ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<f32>`
[INFO] [stdout]   --> src/quant/round.rs:23:34
[INFO] [stdout]    |
[INFO] [stdout] 23 |             F::cast_from(step_up(f32::cast_from(scale), dtype))
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 23 |             F::cast_from(step_up(<cubecl_core::frontend::NativeExpand<f32> as Into<_>>::into(f32::cast_from(scale)), dtype))
[INFO] [stdout]    |                                  ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++                     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::quant::scheme::ScaleDtype`
[INFO] [stdout]   --> src/quant/round.rs:18:58
[INFO] [stdout]    |
[INFO] [stdout] 18 | pub fn round_up_to_dtype<F: Float>(scale: F, #[comptime] dtype: ScaleDtype) -> F {
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 18 | pub fn round_up_to_dtype<F: Float>(scale: F, #[comptime] <cubecl_core::quant::scheme::ScaleDtype as Into<_>>::into(dtype): ScaleDtype) -> F {
[INFO] [stdout]    |                                                          ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<f32>`
[INFO] [stdout]   --> src/quant/round.rs:23:26
[INFO] [stdout]    |
[INFO] [stdout] 23 |             F::cast_from(step_up(f32::cast_from(scale), dtype))
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 23 |             F::cast_from(<cubecl_core::frontend::NativeExpand<f32> as Into<_>>::into(step_up(f32::cast_from(scale), dtype)))
[INFO] [stdout]    |                          ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++                                     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<f32>`
[INFO] [stdout]   --> src/quant/round.rs:25:67
[INFO] [stdout]    |
[INFO] [stdout] 25 |         ScaleDtype::UE8M0 => F::cast_from(step_up_to_power_of_two(f32::cast_from(scale))),
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 25 |         ScaleDtype::UE8M0 => F::cast_from(step_up_to_power_of_two(<cubecl_core::frontend::NativeExpand<f32> as Into<_>>::into(f32::cast_from(scale)))),
[INFO] [stdout]    |                                                                   ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++                     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<f32>`
[INFO] [stdout]   --> src/quant/round.rs:25:43
[INFO] [stdout]    |
[INFO] [stdout] 25 |         ScaleDtype::UE8M0 => F::cast_from(step_up_to_power_of_two(f32::cast_from(scale))),
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 25 |         ScaleDtype::UE8M0 => F::cast_from(<cubecl_core::frontend::NativeExpand<f32> as Into<_>>::into(step_up_to_power_of_two(f32::cast_from(scale)))),
[INFO] [stdout]    |                                           ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++                                              +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<f32>`
[INFO] [stdout]   --> src/quant/round.rs:36:28
[INFO] [stdout]    |
[INFO] [stdout] 36 | fn step_up_to_power_of_two(scale: f32) -> f32 {
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 36 | fn step_up_to_power_of_two(<cubecl_core::frontend::NativeExpand<f32> as Into<_>>::into(scale): f32) -> f32 {
[INFO] [stdout]    |                            ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<f32>`
[INFO] [stdout]   --> src/quant/round.rs:50:12
[INFO] [stdout]    |
[INFO] [stdout] 50 | fn step_up(scale: f32, #[comptime] dtype: ScaleDtype) -> f32 {
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 50 | fn step_up(<cubecl_core::frontend::NativeExpand<f32> as Into<_>>::into(scale): f32, #[comptime] dtype: ScaleDtype) -> f32 {
[INFO] [stdout]    |            ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::quant::scheme::F32Grid`
[INFO] [stdout]   --> src/quant/round.rs:55:9
[INFO] [stdout]    |
[INFO] [stdout] 55 |     let grid = comptime!(dtype.f32_grid());
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 55 |     let <cubecl_core::quant::scheme::F32Grid as Into<_>>::into(grid) = comptime!(dtype.f32_grid());
[INFO] [stdout]    |         +++++++++++++++++++++++++++++++++++++++++++++++++++++++    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<f32>`
[INFO] [stdout]   --> src/quant/round.rs:80:21
[INFO] [stdout]    |
[INFO] [stdout] 80 | fn round_up_on_grid(scale: f32, #[comptime] grid: F32Grid) -> f32 {
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 80 | fn round_up_on_grid(<cubecl_core::frontend::NativeExpand<f32> as Into<_>>::into(scale): f32, #[comptime] grid: F32Grid) -> f32 {
[INFO] [stdout]    |                     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<u32>`
[INFO] [stdout]   --> src/quant/round.rs:82:9
[INFO] [stdout]    |
[INFO] [stdout] 82 |     let up_bits = (bits + comptime!(grid.round_up_bias())) & comptime!(grid.truncate_mask());
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 82 |     let <cubecl_core::frontend::NativeExpand<u32> as Into<_>>::into(up_bits) = (bits + comptime!(grid.round_up_bias())) & comptime!(grid.truncate_mask());
[INFO] [stdout]    |         ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<usize>`
[INFO] [stdout]   --> src/tensor/contiguous/base.rs:35:9
[INFO] [stdout]    |
[INFO] [stdout] 35 |     for i in dim_start..dim_end {
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 35 |     for <cubecl_core::frontend::NativeExpand<usize> as Into<_>>::into(i) in dim_start..dim_end {
[INFO] [stdout]    |         ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<usize>`
[INFO] [stdout]   --> src/tensor/contiguous/base.rs:59:13
[INFO] [stdout]    |
[INFO] [stdout] 59 |         let dim = rank - i - 1;
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 59 |         let <cubecl_core::frontend::NativeExpand<usize> as Into<_>>::into(dim) = rank - i - 1;
[INFO] [stdout]    |             ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<usize>`
[INFO] [stdout]   --> src/tensor/contiguous/base.rs:81:13
[INFO] [stdout]    |
[INFO] [stdout] 81 |     let mut remainder = offset_ref;
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 81 |     let mut <cubecl_core::frontend::NativeExpand<usize> as Into<_>>::into(remainder) = offset_ref;
[INFO] [stdout]    |             ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++         +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]    --> src/tensor/contiguous/base.rs:100:17
[INFO] [stdout]     |
[INFO] [stdout] 100 |     #[comptime] elems_per_thread: usize,
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 100 |     #[comptime] <usize as Into<_>>::into(elems_per_thread): usize,
[INFO] [stdout]     |                 +++++++++++++++++++++++++                +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<usize>`
[INFO] [stdout]    --> src/tensor/contiguous/base.rs:103:9
[INFO] [stdout]     |
[INFO] [stdout] 103 |     let offset_linear = ABSOLUTE_POS * elems_per_thread;
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 103 |     let <cubecl_core::frontend::NativeExpand<usize> as Into<_>>::into(offset_linear) = ABSOLUTE_POS * elems_per_thread;
[INFO] [stdout]     |         ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++             +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&mut cubecl_core::frontend::NativeExpand<[cubecl_core::frontend::Vector<T, N>]>`
[INFO] [stdout]   --> src/tensor/contiguous/base.rs:98:5
[INFO] [stdout]    |
[INFO] [stdout] 98 |     output: &mut [Vector<T, N>],
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 98 |     <&mut cubecl_core::frontend::NativeExpand<[cubecl_core::frontend::Vector<T, N>]> as Into<_>>::into(output): &mut [Vector<T, N>],
[INFO] [stdout]    |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]    --> src/tensor/contiguous/base.rs:129:9
[INFO] [stdout]     |
[INFO] [stdout] 129 |     let vectors_per_thread = elems_per_thread / vector_size;
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 129 |     let <usize as Into<_>>::into(vectors_per_thread) = elems_per_thread / vector_size;
[INFO] [stdout]     |         +++++++++++++++++++++++++                  +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]    --> src/tensor/contiguous/base.rs:141:13
[INFO] [stdout]     |
[INFO] [stdout] 141 |         for k in 0..vector_size {
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 141 |         for <usize as Into<_>>::into(k) in 0..vector_size {
[INFO] [stdout]     |             +++++++++++++++++++++++++ +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<usize>`
[INFO] [stdout]    --> src/tensor/contiguous/base.rs:142:17
[INFO] [stdout]     |
[INFO] [stdout] 142 |             let offset_input = offset_input + offset + k;
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 142 |             let <cubecl_core::frontend::NativeExpand<usize> as Into<_>>::into(offset_input) = offset_input + offset + k;
[INFO] [stdout]     |                 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<T>`
[INFO] [stdout]    --> src/tensor/contiguous/base.rs:143:27
[INFO] [stdout]     |
[INFO] [stdout] 143 |             reg.insert(k, input.read_checked(offset_input));
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 143 |             reg.insert(k, <cubecl_core::frontend::NativeExpand<T> as Into<_>>::into(input.read_checked(offset_input)));
[INFO] [stdout]     |                           ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++                                +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<usize>`
[INFO] [stdout]    --> src/tensor/contiguous/base.rs:131:9
[INFO] [stdout]     |
[INFO] [stdout] 131 |     let offset_output = ABSOLUTE_POS * vectors_per_thread;
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 131 |     let <cubecl_core::frontend::NativeExpand<usize> as Into<_>>::into(offset_output) = ABSOLUTE_POS * vectors_per_thread;
[INFO] [stdout]     |         ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++             +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `cubecl-std` (lib) due to 184 previous errors
[INFO] [stderr] warning: build failed, waiting for other jobs to finish...
[INFO] [stdout] error: useless conversion to the same type: `&mut cubecl_core::frontend::NativeExpand<[cubecl_core::frontend::Vector<T, N>]>`
[INFO] [stdout]    --> src/tensor/contiguous/base.rs:123:5
[INFO] [stdout]     |
[INFO] [stdout] 123 |     output: &mut [Vector<T, N>],
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 123 |     <&mut cubecl_core::frontend::NativeExpand<[cubecl_core::frontend::Vector<T, N>]> as Into<_>>::into(output): &mut [Vector<T, N>],
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<usize>`
[INFO] [stdout]    --> src/tensor/contiguous/base.rs:176:17
[INFO] [stdout]     |
[INFO] [stdout] 176 |         let mut remainder = elem_pos + n;
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 176 |         let mut <cubecl_core::frontend::NativeExpand<usize> as Into<_>>::into(remainder) = elem_pos + n;
[INFO] [stdout]     |                 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++         +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<usize>`
[INFO] [stdout]    --> src/tensor/contiguous/base.rs:192:13
[INFO] [stdout]     |
[INFO] [stdout] 192 |         let shift_in = packing_offset * bits_per_elem;
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 192 |         let <cubecl_core::frontend::NativeExpand<usize> as Into<_>>::into(shift_in) = packing_offset * bits_per_elem;
[INFO] [stdout]     |             ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<usize>`
[INFO] [stdout]    --> src/tensor/contiguous/base.rs:193:13
[INFO] [stdout]     |
[INFO] [stdout] 193 |         let shift_out = n * bits_per_elem;
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 193 |         let <cubecl_core::frontend::NativeExpand<usize> as Into<_>>::into(shift_out) = n * bits_per_elem;
[INFO] [stdout]     |             ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++         +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]    --> src/tensor/contiguous/base.rs:214:9
[INFO] [stdout]     |
[INFO] [stdout] 214 |     let vectors_per_thread = elems_per_thread / vector_size;
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 214 |     let <usize as Into<_>>::into(vectors_per_thread) = elems_per_thread / vector_size;
[INFO] [stdout]     |         +++++++++++++++++++++++++                  +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]    --> src/tensor/contiguous/base.rs:230:13
[INFO] [stdout]     |
[INFO] [stdout] 230 |         for k in 0..vector_size {
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 230 |         for <usize as Into<_>>::into(k) in 0..vector_size {
[INFO] [stdout]     |             +++++++++++++++++++++++++ +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&cubecl_core::frontend::TensorExpand<T>`
[INFO] [stdout]    --> src/tensor/contiguous/base.rs:203:5
[INFO] [stdout]     |
[INFO] [stdout] 203 |     input: &Tensor<T>,
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 203 |     <&cubecl_core::frontend::TensorExpand<T> as Into<_>>::into(input): &Tensor<T>,
[INFO] [stdout]     |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<usize>`
[INFO] [stdout]    --> src/tensor/contiguous/base.rs:231:17
[INFO] [stdout]     |
[INFO] [stdout] 231 |             let offset_input = offset_input + offset + k;
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 231 |             let <cubecl_core::frontend::NativeExpand<usize> as Into<_>>::into(offset_input) = offset_input + offset + k;
[INFO] [stdout]     |                 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]    --> src/tensor/contiguous/base.rs:207:17
[INFO] [stdout]     |
[INFO] [stdout] 207 |     #[comptime] packed_dim: usize,
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 207 |     #[comptime] <usize as Into<_>>::into(packed_dim): usize,
[INFO] [stdout]     |                 +++++++++++++++++++++++++          +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]    --> src/tensor/contiguous/base.rs:208:17
[INFO] [stdout]     |
[INFO] [stdout] 208 |     #[comptime] packing: usize,
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 208 |     #[comptime] <usize as Into<_>>::into(packing): usize,
[INFO] [stdout]     |                 +++++++++++++++++++++++++       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]    --> src/tensor/contiguous/base.rs:209:17
[INFO] [stdout]     |
[INFO] [stdout] 209 |     #[comptime] rank: usize,
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 209 |     #[comptime] <usize as Into<_>>::into(rank): usize,
[INFO] [stdout]     |                 +++++++++++++++++++++++++    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<T>`
[INFO] [stdout]    --> src/tensor/contiguous/base.rs:235:17
[INFO] [stdout]     |
[INFO] [stdout] 235 |                 index_packed(input, offset_input, &in_shape, packed_dim, packing, rank),
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 235 |                 <cubecl_core::frontend::NativeExpand<T> as Into<_>>::into(index_packed(input, offset_input, &in_shape, packed_dim, packing, rank)),
[INFO] [stdout]     |                 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<usize>`
[INFO] [stdout]    --> src/tensor/contiguous/base.rs:216:9
[INFO] [stdout]     |
[INFO] [stdout] 216 |     let offset_output = ABSOLUTE_POS * vectors_per_thread;
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 216 |     let <cubecl_core::frontend::NativeExpand<usize> as Into<_>>::into(offset_output) = ABSOLUTE_POS * vectors_per_thread;
[INFO] [stdout]     |         ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++             +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<usize>`
[INFO] [stdout]   --> src/tensor/contiguous/perpendicular.rs:23:9
[INFO] [stdout]    |
[INFO] [stdout] 23 |     let last_axis = input.rank() - 1;
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 23 |     let <cubecl_core::frontend::NativeExpand<usize> as Into<_>>::into(last_axis) = input.rank() - 1;
[INFO] [stdout]    |         ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++         +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<cubecl_core::frontend::Vector<T, N>>`
[INFO] [stdout]   --> src/tensor/contiguous/perpendicular.rs:33:27
[INFO] [stdout]    |
[INFO] [stdout] 33 |         accumulators.push(Vector::empty());
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 33 |         accumulators.push(<cubecl_core::frontend::NativeExpand<cubecl_core::frontend::Vector<T, N>> as Into<_>>::into(Vector::empty()));
[INFO] [stdout]    |                           ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++               +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<usize>`
[INFO] [stdout]   --> src/tensor/contiguous/perpendicular.rs:19:5
[INFO] [stdout]    |
[INFO] [stdout] 19 |     axis_vectorized: usize,
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 19 |     <cubecl_core::frontend::NativeExpand<usize> as Into<_>>::into(axis_vectorized): usize,
[INFO] [stdout]    |     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++               +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<usize>`
[INFO] [stdout]   --> src/tensor/contiguous/perpendicular.rs:62:13
[INFO] [stdout]    |
[INFO] [stdout] 62 |         for axis in 0..input.rank() {
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 62 |         for <cubecl_core::frontend::NativeExpand<usize> as Into<_>>::into(axis) in 0..input.rank() {
[INFO] [stdout]    |             ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]   --> src/tensor/contiguous/perpendicular.rs:72:13
[INFO] [stdout]    |
[INFO] [stdout] 72 |         for i in 0..vector_size {
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 72 |         for <usize as Into<_>>::into(i) in 0..vector_size {
[INFO] [stdout]    |             +++++++++++++++++++++++++ +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]   --> src/tensor/contiguous/perpendicular.rs:79:17
[INFO] [stdout]    |
[INFO] [stdout] 79 |             for o in 0..vector_size {
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 79 |             for <usize as Into<_>>::into(o) in 0..vector_size {
[INFO] [stdout]    |                 +++++++++++++++++++++++++ +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<T>`
[INFO] [stdout]   --> src/tensor/contiguous/perpendicular.rs:81:34
[INFO] [stdout]    |
[INFO] [stdout] 81 |                 vector.insert(i, batched.extract(o));
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 81 |                 vector.insert(i, <cubecl_core::frontend::NativeExpand<T> as Into<_>>::into(batched.extract(o)));
[INFO] [stdout]    |                                  ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++                  +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<C>`
[INFO] [stdout]    --> src/tensor/handle.rs:199:54
[INFO] [stdout]     |
[INFO] [stdout] 199 |             output[ABSOLUTE_POS] = Vector::cast_from(C::from_int(0));
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 199 |             output[ABSOLUTE_POS] = Vector::cast_from(<cubecl_core::frontend::NativeExpand<C> as Into<_>>::into(C::from_int(0)));
[INFO] [stdout]     |                                                      ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++              +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<C>`
[INFO] [stdout]   --> src/tensor/identity.rs:18:38
[INFO] [stdout]    |
[INFO] [stdout] 18 |         let mut vector = Vector::new(C::from_int(0));
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 18 |         let mut vector = Vector::new(<cubecl_core::frontend::NativeExpand<C> as Into<_>>::into(C::from_int(0)));
[INFO] [stdout]    |                                      ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++              +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<usize>`
[INFO] [stdout]   --> src/tensor/identity.rs:22:17
[INFO] [stdout]    |
[INFO] [stdout] 22 |         let mut offset = 0;
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 22 |         let mut <cubecl_core::frontend::NativeExpand<usize> as Into<_>>::into(offset) = 0;
[INFO] [stdout]    |                 ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<C>`
[INFO] [stdout]   --> src/tensor/identity.rs:26:47
[INFO] [stdout]    |
[INFO] [stdout] 26 |                 vector.insert_dynamic(offset, C::from_int(1));
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 26 |                 vector.insert_dynamic(offset, <cubecl_core::frontend::NativeExpand<C> as Into<_>>::into(C::from_int(1)));
[INFO] [stdout]    |                                               ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++              +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<T as cubecl_core::frontend::CubeType>::ExpandType`
[INFO] [stdout]    --> src/tensor/layout/coordinates.rs:118:22
[INFO] [stdout]     |
[INFO] [stdout] 118 |             out.push(T::add(this[i], other[i]));
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 118 |             out.push(<<T as cubecl_core::frontend::CubeType>::ExpandType as Into<_>>::into(T::add(this[i], other[i])));
[INFO] [stdout]     |                      ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++                         +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<T as cubecl_core::frontend::CubeType>::ExpandType`
[INFO] [stdout]    --> src/tensor/layout/coordinates.rs:130:22
[INFO] [stdout]     |
[INFO] [stdout] 130 |             out.push(T::sub(this[i], other[i]));
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 130 |             out.push(<<T as cubecl_core::frontend::CubeType>::ExpandType as Into<_>>::into(T::sub(this[i], other[i])));
[INFO] [stdout]     |                      ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++                         +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<T as cubecl_core::frontend::CubeType>::ExpandType`
[INFO] [stdout]    --> src/tensor/layout/coordinates.rs:142:22
[INFO] [stdout]     |
[INFO] [stdout] 142 |             out.push(T::min(this[i], other[i]));
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 142 |             out.push(<<T as cubecl_core::frontend::CubeType>::ExpandType as Into<_>>::into(T::min(this[i], other[i])));
[INFO] [stdout]     |                      ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++                         +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<T as cubecl_core::frontend::CubeType>::ExpandType`
[INFO] [stdout]    --> src/tensor/layout/coordinates.rs:154:22
[INFO] [stdout]     |
[INFO] [stdout] 154 |             out.push(T::max(this[i], other[i]));
[INFO] [stdout]     |                      ^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 154 |             out.push(<<T as cubecl_core::frontend::CubeType>::ExpandType as Into<_>>::into(T::max(this[i], other[i])));
[INFO] [stdout]     |                      ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++                         +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `i64`
[INFO] [stdout]    --> src/tensor/layout/coordinates.rs:172:41
[INFO] [stdout]     |
[INFO] [stdout] 172 |     fn from_int(this: Self, #[comptime] value: i64) -> Self {
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 172 |     fn from_int(this: Self, #[comptime] <i64 as Into<_>>::into(value): i64) -> Self {
[INFO] [stdout]     |                                         +++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<T as cubecl_core::frontend::CubeType>::ExpandType`
[INFO] [stdout]    --> src/tensor/layout/coordinates.rs:178:25
[INFO] [stdout]     |
[INFO] [stdout] 178 |             origin.push(T::from_int(this[i], value));
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 178 |             origin.push(<<T as cubecl_core::frontend::CubeType>::ExpandType as Into<_>>::into(T::from_int(this[i], value)));
[INFO] [stdout]     |                         ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++                           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<u32>`
[INFO] [stdout]   --> src/tensor/layout/as_dyn.rs:48:13
[INFO] [stdout]    |
[INFO] [stdout] 48 |         for x in self {
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 48 |         for <cubecl_core::frontend::NativeExpand<u32> as Into<_>>::into(x) in self {
[INFO] [stdout]    |             ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<i32>`
[INFO] [stdout]   --> src/tensor/layout/as_dyn.rs:49:22
[INFO] [stdout]    |
[INFO] [stdout] 49 |             seq.push(i32::cast_from(x));
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 49 |             seq.push(<cubecl_core::frontend::NativeExpand<i32> as Into<_>>::into(i32::cast_from(x)));
[INFO] [stdout]    |                      ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<<L as Layout>::Coordinates as CubeType>::ExpandType`
[INFO] [stdout]    --> src/tensor/layout/as_dyn.rs:159:29
[INFO] [stdout]     |
[INFO] [stdout] 159 |     fn to_source_pos(&self, pos: Self::Coordinates) -> Self::SourceCoordinates {
[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: the full name for the type has been written to '/opt/rustwide/target/debug/build/cubecl-std/8508089d34faaf71/out/cubecl_std-8508089d34faaf71.long-type-16865144497279843782.txt'
[INFO] [stdout]     = note: consider using `--verbose` to print the full type name to the console
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 159 |     fn to_source_pos(&self, <<<L as tensor::layout::base::Layout>::Coordinates as cubecl_core::frontend::CubeType>::ExpandType as Into<_>>::into(pos): Self::Coordinates) -> Self::SourceCoordinates {
[INFO] [stdout]     |                             +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<<L as Layout>::Coordinates as CubeType>::ExpandType`
[INFO] [stdout]    --> src/tensor/layout/as_dyn.rs:164:28
[INFO] [stdout]     |
[INFO] [stdout] 164 |     fn is_in_bounds(&self, pos: Self::Coordinates) -> bool {
[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: the full name for the type has been written to '/opt/rustwide/target/debug/build/cubecl-std/8508089d34faaf71/out/cubecl_std-8508089d34faaf71.long-type-16865144497279843782.txt'
[INFO] [stdout]     = note: consider using `--verbose` to print the full type name to the console
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 164 |     fn is_in_bounds(&self, <<<L as tensor::layout::base::Layout>::Coordinates as cubecl_core::frontend::CubeType>::ExpandType as Into<_>>::into(pos): Self::Coordinates) -> bool {
[INFO] [stdout]     |                            +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<<L as Layout>::Coordinates as CubeType>::ExpandType`
[INFO] [stdout]    --> src/tensor/layout/as_dyn.rs:168:37
[INFO] [stdout]     |
[INFO] [stdout] 168 |     fn to_source_pos_checked(&self, pos: Self::Coordinates) -> (Self::SourceCoordinates, bool) {
[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: the full name for the type has been written to '/opt/rustwide/target/debug/build/cubecl-std/8508089d34faaf71/out/cubecl_std-8508089d34faaf71.long-type-16865144497279843782.txt'
[INFO] [stdout]     = note: consider using `--verbose` to print the full type name to the console
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 168 |     fn to_source_pos_checked(&self, <<<L as tensor::layout::base::Layout>::Coordinates as cubecl_core::frontend::CubeType>::ExpandType as Into<_>>::into(pos): Self::Coordinates) -> (Self::SourceCoordinates, bool) {
[INFO] [stdout]     |                                     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<<L as Layout>::Coordinates as CubeType>::ExpandType`
[INFO] [stdout]    --> src/tensor/layout/as_dyn.rs:188:29
[INFO] [stdout]     |
[INFO] [stdout] 188 |     fn to_source_pos(&self, pos: Self::Coordinates) -> Self::SourceCoordinates {
[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: the full name for the type has been written to '/opt/rustwide/target/debug/build/cubecl-std/8508089d34faaf71/out/cubecl_std-8508089d34faaf71.long-type-16865144497279843782.txt'
[INFO] [stdout]     = note: consider using `--verbose` to print the full type name to the console
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 188 |     fn to_source_pos(&self, <<<L as tensor::layout::base::Layout>::Coordinates as cubecl_core::frontend::CubeType>::ExpandType as Into<_>>::into(pos): Self::Coordinates) -> Self::SourceCoordinates {
[INFO] [stdout]     |                             +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<<L as Layout>::Coordinates as CubeType>::ExpandType`
[INFO] [stdout]    --> src/tensor/layout/as_dyn.rs:193:28
[INFO] [stdout]     |
[INFO] [stdout] 193 |     fn is_in_bounds(&self, pos: Self::Coordinates) -> bool {
[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: the full name for the type has been written to '/opt/rustwide/target/debug/build/cubecl-std/8508089d34faaf71/out/cubecl_std-8508089d34faaf71.long-type-16865144497279843782.txt'
[INFO] [stdout]     = note: consider using `--verbose` to print the full type name to the console
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 193 |     fn is_in_bounds(&self, <<<L as tensor::layout::base::Layout>::Coordinates as cubecl_core::frontend::CubeType>::ExpandType as Into<_>>::into(pos): Self::Coordinates) -> bool {
[INFO] [stdout]     |                            +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<<L as Layout>::Coordinates as CubeType>::ExpandType`
[INFO] [stdout]    --> src/tensor/layout/as_dyn.rs:197:37
[INFO] [stdout]     |
[INFO] [stdout] 197 |     fn to_source_pos_checked(&self, pos: Self::Coordinates) -> (Self::SourceCoordinates, bool) {
[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: the full name for the type has been written to '/opt/rustwide/target/debug/build/cubecl-std/8508089d34faaf71/out/cubecl_std-8508089d34faaf71.long-type-16865144497279843782.txt'
[INFO] [stdout]     = note: consider using `--verbose` to print the full type name to the console
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 197 |     fn to_source_pos_checked(&self, <<<L as tensor::layout::base::Layout>::Coordinates as cubecl_core::frontend::CubeType>::ExpandType as Into<_>>::into(pos): Self::Coordinates) -> (Self::SourceCoordinates, bool) {
[INFO] [stdout]     |                                     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<<L1 as Layout>::Coordinates as CubeType>::ExpandType`
[INFO] [stdout]   --> src/tensor/layout/chain.rs:25:29
[INFO] [stdout]    |
[INFO] [stdout] 25 |     fn to_source_pos(&self, pos: Self::Coordinates) -> Self::SourceCoordinates {
[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: the full name for the type has been written to '/opt/rustwide/target/debug/build/cubecl-std/8508089d34faaf71/out/cubecl_std-8508089d34faaf71.long-type-3001898775089685839.txt'
[INFO] [stdout]    = note: consider using `--verbose` to print the full type name to the console
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 25 |     fn to_source_pos(&self, <<<L1 as tensor::layout::base::Layout>::Coordinates as cubecl_core::frontend::CubeType>::ExpandType as Into<_>>::into(pos): Self::Coordinates) -> Self::SourceCoordinates {
[INFO] [stdout]    |                             ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<<L0 as Layout>::Coordinates as CubeType>::ExpandType`
[INFO] [stdout]   --> src/tensor/layout/chain.rs:26:13
[INFO] [stdout]    |
[INFO] [stdout] 26 |         let pos = self.l1.to_source_pos(pos);
[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: the full name for the type has been written to '/opt/rustwide/target/debug/build/cubecl-std/8508089d34faaf71/out/cubecl_std-8508089d34faaf71.long-type-5492515236609920072.txt'
[INFO] [stdout]    = note: consider using `--verbose` to print the full type name to the console
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 26 |         let <<<L0 as tensor::layout::base::Layout>::Coordinates as cubecl_core::frontend::CubeType>::ExpandType as Into<_>>::into(pos) = self.l1.to_source_pos(pos);
[INFO] [stdout]    |             ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<<L1 as Layout>::Coordinates as CubeType>::ExpandType`
[INFO] [stdout]   --> src/tensor/layout/chain.rs:30:28
[INFO] [stdout]    |
[INFO] [stdout] 30 |     fn is_in_bounds(&self, pos: Self::Coordinates) -> bool {
[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: the full name for the type has been written to '/opt/rustwide/target/debug/build/cubecl-std/8508089d34faaf71/out/cubecl_std-8508089d34faaf71.long-type-3001898775089685839.txt'
[INFO] [stdout]    = note: consider using `--verbose` to print the full type name to the console
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 30 |     fn is_in_bounds(&self, <<<L1 as tensor::layout::base::Layout>::Coordinates as cubecl_core::frontend::CubeType>::ExpandType as Into<_>>::into(pos): Self::Coordinates) -> bool {
[INFO] [stdout]    |                            ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<<L0 as Layout>::Coordinates as CubeType>::ExpandType`
[INFO] [stdout]   --> src/tensor/layout/chain.rs:31:14
[INFO] [stdout]    |
[INFO] [stdout] 31 |         let (pos, l1_in_bounds) = self.l1.to_source_pos_checked(pos);
[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: the full name for the type has been written to '/opt/rustwide/target/debug/build/cubecl-std/8508089d34faaf71/out/cubecl_std-8508089d34faaf71.long-type-5492515236609920072.txt'
[INFO] [stdout]    = note: consider using `--verbose` to print the full type name to the console
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 31 |         let (<<<L0 as tensor::layout::base::Layout>::Coordinates as cubecl_core::frontend::CubeType>::ExpandType as Into<_>>::into(pos), l1_in_bounds) = self.l1.to_source_pos_checked(pos);
[INFO] [stdout]    |              ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<<L1 as Layout>::Coordinates as CubeType>::ExpandType`
[INFO] [stdout]   --> src/tensor/layout/chain.rs:35:37
[INFO] [stdout]    |
[INFO] [stdout] 35 |     fn to_source_pos_checked(&self, pos: Self::Coordinates) -> (Self::SourceCoordinates, bool) {
[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: the full name for the type has been written to '/opt/rustwide/target/debug/build/cubecl-std/8508089d34faaf71/out/cubecl_std-8508089d34faaf71.long-type-3001898775089685839.txt'
[INFO] [stdout]    = note: consider using `--verbose` to print the full type name to the console
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 35 |     fn to_source_pos_checked(&self, <<<L1 as tensor::layout::base::Layout>::Coordinates as cubecl_core::frontend::CubeType>::ExpandType as Into<_>>::into(pos): Self::Coordinates) -> (Self::SourceCoordinates, bool) {
[INFO] [stdout]    |                                     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<<L0 as Layout>::Coordinates as CubeType>::ExpandType`
[INFO] [stdout]   --> src/tensor/layout/chain.rs:36:14
[INFO] [stdout]    |
[INFO] [stdout] 36 |         let (pos, l1_in_bounds) = self.l1.to_source_pos_checked(pos);
[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: the full name for the type has been written to '/opt/rustwide/target/debug/build/cubecl-std/8508089d34faaf71/out/cubecl_std-8508089d34faaf71.long-type-5492515236609920072.txt'
[INFO] [stdout]    = note: consider using `--verbose` to print the full type name to the console
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 36 |         let (<<<L0 as tensor::layout::base::Layout>::Coordinates as cubecl_core::frontend::CubeType>::ExpandType as Into<_>>::into(pos), l1_in_bounds) = self.l1.to_source_pos_checked(pos);
[INFO] [stdout]    |              ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::SequenceExpand<u32>`
[INFO] [stdout]   --> src/tensor/layout/dynamic_rank_strided.rs:36:29
[INFO] [stdout]    |
[INFO] [stdout] 36 |         (self.to_source_pos(pos.clone()), self.is_in_bounds(pos))
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 36 |         (self.to_source_pos(<cubecl_core::frontend::SequenceExpand<u32> as Into<_>>::into(pos.clone())), self.is_in_bounds(pos))
[INFO] [stdout]    |                             ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::SequenceExpand<u32>`
[INFO] [stdout]   --> src/tensor/layout/dynamic_rank_strided.rs:35:37
[INFO] [stdout]    |
[INFO] [stdout] 35 |     fn to_source_pos_checked(&self, pos: Self::Coordinates) -> (Self::SourceCoordinates, bool) {
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 35 |     fn to_source_pos_checked(&self, <cubecl_core::frontend::SequenceExpand<u32> as Into<_>>::into(pos): Self::Coordinates) -> (Self::SourceCoordinates, bool) {
[INFO] [stdout]    |                                     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<D as cubecl_core::frontend::CubeType>::ExpandType`
[INFO] [stdout]   --> src/tensor/layout/fixed_dim.rs:68:29
[INFO] [stdout]    |
[INFO] [stdout] 68 |         (self.to_source_pos(pos.clone()), self.is_in_bounds(pos))
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 68 |         (self.to_source_pos(<<D as cubecl_core::frontend::CubeType>::ExpandType as Into<_>>::into(pos.clone())), self.is_in_bounds(pos))
[INFO] [stdout]    |                             ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<D as cubecl_core::frontend::CubeType>::ExpandType`
[INFO] [stdout]   --> src/tensor/layout/fixed_dim.rs:67:37
[INFO] [stdout]    |
[INFO] [stdout] 67 |     fn to_source_pos_checked(&self, pos: Self::Coordinates) -> (Self::SourceCoordinates, bool) {
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 67 |     fn to_source_pos_checked(&self, <<D as cubecl_core::frontend::CubeType>::ExpandType as Into<_>>::into(pos): Self::Coordinates) -> (Self::SourceCoordinates, bool) {
[INFO] [stdout]    |                                     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<usize>`
[INFO] [stdout]    --> src/tensor/layout/linear.rs:141:37
[INFO] [stdout]     |
[INFO] [stdout] 141 |     fn to_source_pos_checked(&self, pos: Self::Coordinates) -> (usize, bool) {
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 141 |     fn to_source_pos_checked(&self, <cubecl_core::frontend::NativeExpand<usize> as Into<_>>::into(pos): Self::Coordinates) -> (usize, bool) {
[INFO] [stdout]     |                                     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<usize>`
[INFO] [stdout]    --> src/tensor/layout/permuted.rs:145:29
[INFO] [stdout]     |
[INFO] [stdout] 145 |     fn to_source_pos(&self, pos: Self::Coordinates) -> usize {
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 145 |     fn to_source_pos(&self, <cubecl_core::frontend::NativeExpand<usize> as Into<_>>::into(pos): Self::Coordinates) -> usize {
[INFO] [stdout]     |                             ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]    --> src/tensor/layout/permuted.rs:145:22
[INFO] [stdout]     |
[INFO] [stdout] 145 |       fn to_source_pos(&self, pos: Self::Coordinates) -> usize {
[INFO] [stdout]     |  ______________________^
[INFO] [stdout] 146 | |         index_offset_contiguous_fastdivmod(pos, &self.shape, &self.strides, self.vector_size)
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 145 ~     fn to_source_pos(<usize as Into<_>>::into(&self, pos: Self::Coordinates) -> usize {
[INFO] [stdout] 146 ~         index_offset_contiguous_fastdivmod(pos, &self.shape, &self.strides, self.vector_size))
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<usize>`
[INFO] [stdout]    --> src/tensor/layout/permuted.rs:149:37
[INFO] [stdout]     |
[INFO] [stdout] 149 |     fn to_source_pos_checked(&self, pos: Self::Coordinates) -> (usize, bool) {
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 149 |     fn to_source_pos_checked(&self, <cubecl_core::frontend::NativeExpand<usize> as Into<_>>::into(pos): Self::Coordinates) -> (usize, bool) {
[INFO] [stdout]     |                                     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<usize>`
[INFO] [stdout]   --> src/tensor/layout/plain.rs:54:37
[INFO] [stdout]    |
[INFO] [stdout] 54 |     fn to_source_pos_checked(&self, pos: Self::Coordinates) -> (usize, bool) {
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 54 |     fn to_source_pos_checked(&self, <cubecl_core::frontend::NativeExpand<usize> as Into<_>>::into(pos): Self::Coordinates) -> (usize, bool) {
[INFO] [stdout]    |                                     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<usize>`
[INFO] [stdout]   --> src/tensor/layout/simple.rs:46:37
[INFO] [stdout]    |
[INFO] [stdout] 46 |     fn to_source_pos_checked(&self, pos: Self::Coordinates) -> (usize, bool) {
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 46 |     fn to_source_pos_checked(&self, <cubecl_core::frontend::NativeExpand<usize> as Into<_>>::into(pos): Self::Coordinates) -> (usize, bool) {
[INFO] [stdout]    |                                     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<C as cubecl_core::frontend::CubeType>::ExpandType`
[INFO] [stdout]   --> src/tensor/layout/slice.rs:47:16
[INFO] [stdout]    |
[INFO] [stdout] 47 |         C::add(self.offset(), pos)
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 47 |         C::add(<<C as cubecl_core::frontend::CubeType>::ExpandType as Into<_>>::into(self.offset()), pos)
[INFO] [stdout]    |                ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++             +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<C as cubecl_core::frontend::CubeType>::ExpandType`
[INFO] [stdout]   --> src/tensor/layout/slice.rs:46:29
[INFO] [stdout]    |
[INFO] [stdout] 46 |     fn to_source_pos(&self, pos: Self::Coordinates) -> Self::SourceCoordinates {
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 46 |     fn to_source_pos(&self, <<C as cubecl_core::frontend::CubeType>::ExpandType as Into<_>>::into(pos): Self::Coordinates) -> Self::SourceCoordinates {
[INFO] [stdout]    |                             ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<C as cubecl_core::frontend::CubeType>::ExpandType`
[INFO] [stdout]   --> src/tensor/layout/slice.rs:50:28
[INFO] [stdout]    |
[INFO] [stdout] 50 |     fn is_in_bounds(&self, pos: Self::Coordinates) -> bool {
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 50 |     fn is_in_bounds(&self, <<C as cubecl_core::frontend::CubeType>::ExpandType as Into<_>>::into(pos): Self::Coordinates) -> bool {
[INFO] [stdout]    |                            ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<C as cubecl_core::frontend::CubeType>::ExpandType`
[INFO] [stdout]   --> src/tensor/layout/slice.rs:53:34
[INFO] [stdout]    |
[INFO] [stdout] 53 |             C::is_in_bounds(pos, self.size.clone())
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 53 |             C::is_in_bounds(pos, <<C as cubecl_core::frontend::CubeType>::ExpandType as Into<_>>::into(self.size.clone()))
[INFO] [stdout]    |                                  ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<usize>`
[INFO] [stdout]   --> src/tensor/layout/strided.rs:70:13
[INFO] [stdout]    |
[INFO] [stdout] 70 |         let offset_abs = pos * self.vector_size;
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 70 |         let <cubecl_core::frontend::NativeExpand<usize> as Into<_>>::into(offset_abs) = pos * self.vector_size;
[INFO] [stdout]    |             ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++          +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<usize>`
[INFO] [stdout]   --> src/tensor/layout/strided.rs:76:37
[INFO] [stdout]    |
[INFO] [stdout] 76 |     fn to_source_pos_checked(&self, pos: Self::Coordinates) -> (usize, bool) {
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 76 |     fn to_source_pos_checked(&self, <cubecl_core::frontend::NativeExpand<usize> as Into<_>>::into(pos): Self::Coordinates) -> (usize, bool) {
[INFO] [stdout]    |                                     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<u32>`
[INFO] [stdout]   --> src/tensor/layout/tiled_view.rs:78:21
[INFO] [stdout]    |
[INFO] [stdout] 78 |                 let digit = pos[comptime!(self.start_axis + i)] / divisor;
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 78 |                 let <cubecl_core::frontend::NativeExpand<u32> as Into<_>>::into(digit) = pos[comptime!(self.start_axis + i)] / divisor;
[INFO] [stdout]    |                     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::SequenceExpand<u32>`
[INFO] [stdout]   --> src/tensor/layout/tiled_view.rs:95:43
[INFO] [stdout]    |
[INFO] [stdout] 95 |         let in_bounds = self.is_in_bounds(pos.clone());
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 95 |         let in_bounds = self.is_in_bounds(<cubecl_core::frontend::SequenceExpand<u32> as Into<_>>::into(pos.clone()));
[INFO] [stdout]    |                                           ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::SequenceExpand<u32>`
[INFO] [stdout]   --> src/tensor/layout/tiled_view.rs:94:37
[INFO] [stdout]    |
[INFO] [stdout] 94 |     fn to_source_pos_checked(&self, pos: Self::Coordinates) -> (Self::SourceCoordinates, bool) {
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 94 |     fn to_source_pos_checked(&self, <cubecl_core::frontend::SequenceExpand<u32> as Into<_>>::into(pos): Self::Coordinates) -> (Self::SourceCoordinates, bool) {
[INFO] [stdout]    |                                     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<u32>`
[INFO] [stdout]    --> src/tensor/layout/tiled_view.rs:116:21
[INFO] [stdout]     |
[INFO] [stdout] 116 |             let mut extent = 1u32;
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 116 |             let mut <cubecl_core::frontend::NativeExpand<u32> as Into<_>>::into(extent) = 1u32;
[INFO] [stdout]     |                     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::SequenceExpand<u32>`
[INFO] [stdout]    --> src/tensor/layout/tiled_view.rs:164:13
[INFO] [stdout]     |
[INFO] [stdout] 164 |             self.physical_shape.clone(),
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 164 |             <cubecl_core::frontend::SequenceExpand<u32> as Into<_>>::into(self.physical_shape.clone()),
[INFO] [stdout]     |             ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++                           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]    --> src/tensor/layout/tiled_view.rs:162:22
[INFO] [stdout]     |
[INFO] [stdout] 162 |       fn to_source_pos(&self, pos: Self::Coordinates) -> Self::SourceCoordinates {
[INFO] [stdout]     |  ______________________^
[INFO] [stdout] 163 | |         let split = TiledLayout::new(
[INFO] [stdout] 164 | |             self.physical_shape.clone(),
[INFO] [stdout] 165 | |             self.start_axis,
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 162 ~     fn to_source_pos(<usize as Into<_>>::into(&self, pos: Self::Coordinates) -> Self::SourceCoordinates {
[INFO] [stdout] 163 |         let split = TiledLayout::new(
[INFO] [stdout] 164 |             self.physical_shape.clone(),
[INFO] [stdout] 165 ~             self.start_axis),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]    --> src/tensor/layout/tiled_view.rs:162:22
[INFO] [stdout]     |
[INFO] [stdout] 162 |       fn to_source_pos(&self, pos: Self::Coordinates) -> Self::SourceCoordinates {
[INFO] [stdout]     |  ______________________^
[INFO] [stdout] 163 | |         let split = TiledLayout::new(
[INFO] [stdout] 164 | |             self.physical_shape.clone(),
[INFO] [stdout] 165 | |             self.start_axis,
[INFO] [stdout] 166 | |             self.num_tiled,
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 162 ~     fn to_source_pos(<usize as Into<_>>::into(&self, pos: Self::Coordinates) -> Self::SourceCoordinates {
[INFO] [stdout] 163 |         let split = TiledLayout::new(
[INFO] [stdout] 164 |             self.physical_shape.clone(),
[INFO] [stdout] 165 |             self.start_axis,
[INFO] [stdout] 166 ~             self.num_tiled),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]    --> src/tensor/layout/tiled_view.rs:162:22
[INFO] [stdout]     |
[INFO] [stdout] 162 |       fn to_source_pos(&self, pos: Self::Coordinates) -> Self::SourceCoordinates {
[INFO] [stdout]     |  ______________________^
[INFO] [stdout] 163 | |         let split = TiledLayout::new(
[INFO] [stdout] 164 | |             self.physical_shape.clone(),
[INFO] [stdout] 165 | |             self.start_axis,
[INFO] [stdout] 166 | |             self.num_tiled,
[INFO] [stdout] 167 | |             self.levels,
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 162 ~     fn to_source_pos(<usize as Into<_>>::into(&self, pos: Self::Coordinates) -> Self::SourceCoordinates {
[INFO] [stdout] 163 |         let split = TiledLayout::new(
[INFO] [stdout] ...
[INFO] [stdout] 166 |             self.num_tiled,
[INFO] [stdout] 167 ~             self.levels),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::SequenceExpand<u32>`
[INFO] [stdout]    --> src/tensor/layout/tiled_view.rs:162:29
[INFO] [stdout]     |
[INFO] [stdout] 162 |     fn to_source_pos(&self, pos: Self::Coordinates) -> Self::SourceCoordinates {
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 162 |     fn to_source_pos(&self, <cubecl_core::frontend::SequenceExpand<u32> as Into<_>>::into(pos): Self::Coordinates) -> Self::SourceCoordinates {
[INFO] [stdout]     |                             ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::SequenceExpand<u32>`
[INFO] [stdout]    --> src/tensor/layout/tiled_view.rs:180:43
[INFO] [stdout]     |
[INFO] [stdout] 180 |         let in_bounds = self.is_in_bounds(pos.clone());
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 180 |         let in_bounds = self.is_in_bounds(<cubecl_core::frontend::SequenceExpand<u32> as Into<_>>::into(pos.clone()));
[INFO] [stdout]     |                                           ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::SequenceExpand<u32>`
[INFO] [stdout]    --> src/tensor/layout/tiled_view.rs:179:37
[INFO] [stdout]     |
[INFO] [stdout] 179 |     fn to_source_pos_checked(&self, pos: Self::Coordinates) -> (Self::SourceCoordinates, bool) {
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 179 |     fn to_source_pos_checked(&self, <cubecl_core::frontend::SequenceExpand<u32> as Into<_>>::into(pos): Self::Coordinates) -> (Self::SourceCoordinates, bool) {
[INFO] [stdout]     |                                     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::SequenceExpand<u32>`
[INFO] [stdout]    --> src/tensor/layout/tiled_view.rs:186:13
[INFO] [stdout]     |
[INFO] [stdout] 186 |             self.physical_shape.clone(),
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 186 |             <cubecl_core::frontend::SequenceExpand<u32> as Into<_>>::into(self.physical_shape.clone()),
[INFO] [stdout]     |             ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++                           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]    --> src/tensor/layout/tiled_view.rs:184:14
[INFO] [stdout]     |
[INFO] [stdout] 184 |       fn shape(&self) -> Self::Coordinates {
[INFO] [stdout]     |  ______________^
[INFO] [stdout] 185 | |         let split = TiledLayout::new(
[INFO] [stdout] 186 | |             self.physical_shape.clone(),
[INFO] [stdout] 187 | |             self.start_axis,
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 184 ~     fn shape(<usize as Into<_>>::into(&self) -> Self::Coordinates {
[INFO] [stdout] 185 |         let split = TiledLayout::new(
[INFO] [stdout] 186 |             self.physical_shape.clone(),
[INFO] [stdout] 187 ~             self.start_axis),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]    --> src/tensor/layout/tiled_view.rs:184:14
[INFO] [stdout]     |
[INFO] [stdout] 184 |       fn shape(&self) -> Self::Coordinates {
[INFO] [stdout]     |  ______________^
[INFO] [stdout] 185 | |         let split = TiledLayout::new(
[INFO] [stdout] 186 | |             self.physical_shape.clone(),
[INFO] [stdout] 187 | |             self.start_axis,
[INFO] [stdout] 188 | |             self.num_tiled,
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 184 ~     fn shape(<usize as Into<_>>::into(&self) -> Self::Coordinates {
[INFO] [stdout] 185 |         let split = TiledLayout::new(
[INFO] [stdout] 186 |             self.physical_shape.clone(),
[INFO] [stdout] 187 |             self.start_axis,
[INFO] [stdout] 188 ~             self.num_tiled),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]    --> src/tensor/layout/tiled_view.rs:184:14
[INFO] [stdout]     |
[INFO] [stdout] 184 |       fn shape(&self) -> Self::Coordinates {
[INFO] [stdout]     |  ______________^
[INFO] [stdout] 185 | |         let split = TiledLayout::new(
[INFO] [stdout] 186 | |             self.physical_shape.clone(),
[INFO] [stdout] 187 | |             self.start_axis,
[INFO] [stdout] 188 | |             self.num_tiled,
[INFO] [stdout] 189 | |             self.levels,
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 184 ~     fn shape(<usize as Into<_>>::into(&self) -> Self::Coordinates {
[INFO] [stdout] 185 |         let split = TiledLayout::new(
[INFO] [stdout] ...
[INFO] [stdout] 188 |             self.num_tiled,
[INFO] [stdout] 189 ~             self.levels),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<<L as Layout>::Coordinates as CubeType>::ExpandType`
[INFO] [stdout]    --> src/tensor/view/launch.rs:257:33
[INFO] [stdout]     |
[INFO] [stdout] 257 |         fn to_source_pos(&self, pos: Self::Coordinates) -> Self::SourceCoordinates {
[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: the full name for the type has been written to '/opt/rustwide/target/debug/build/cubecl-std/8508089d34faaf71/out/cubecl_std-8508089d34faaf71.long-type-16865144497279843782.txt'
[INFO] [stdout]     = note: consider using `--verbose` to print the full type name to the console
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 257 |         fn to_source_pos(&self, <<<L as tensor::layout::base::Layout>::Coordinates as cubecl_core::frontend::CubeType>::ExpandType as Into<_>>::into(pos): Self::Coordinates) -> Self::SourceCoordinates {
[INFO] [stdout]     |                                 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<<L as Layout>::Coordinates as CubeType>::ExpandType`
[INFO] [stdout]    --> src/tensor/view/launch.rs:261:41
[INFO] [stdout]     |
[INFO] [stdout] 261 |         fn to_source_pos_checked(&self, pos: Self::Coordinates) -> (Self::SourceCoordinates, bool) {
[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: the full name for the type has been written to '/opt/rustwide/target/debug/build/cubecl-std/8508089d34faaf71/out/cubecl_std-8508089d34faaf71.long-type-16865144497279843782.txt'
[INFO] [stdout]     = note: consider using `--verbose` to print the full type name to the console
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 261 |         fn to_source_pos_checked(&self, <<<L as tensor::layout::base::Layout>::Coordinates as cubecl_core::frontend::CubeType>::ExpandType as Into<_>>::into(pos): Self::Coordinates) -> (Self::SourceCoordinates, bool) {
[INFO] [stdout]     |                                         +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `<<L as Layout>::Coordinates as CubeType>::ExpandType`
[INFO] [stdout]    --> src/tensor/view/launch.rs:269:32
[INFO] [stdout]     |
[INFO] [stdout] 269 |         fn is_in_bounds(&self, pos: Self::Coordinates) -> bool {
[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: the full name for the type has been written to '/opt/rustwide/target/debug/build/cubecl-std/8508089d34faaf71/out/cubecl_std-8508089d34faaf71.long-type-16865144497279843782.txt'
[INFO] [stdout]     = note: consider using `--verbose` to print the full type name to the console
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 269 |         fn is_in_bounds(&self, <<<L as tensor::layout::base::Layout>::Coordinates as cubecl_core::frontend::CubeType>::ExpandType as Into<_>>::into(pos): Self::Coordinates) -> bool {
[INFO] [stdout]     |                                +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<usize>`
[INFO] [stdout]    --> src/tensor/virtual.rs:106:23
[INFO] [stdout]     |
[INFO] [stdout] 106 |         self.slice(0, self.len())
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 106 |         self.slice(0, <cubecl_core::frontend::NativeExpand<usize> as Into<_>>::into(self.len()))
[INFO] [stdout]     |                       ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++          +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<usize>`
[INFO] [stdout]    --> src/tensor/virtual.rs:110:27
[INFO] [stdout]     |
[INFO] [stdout] 110 |         self.slice_mut(0, self.len())
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 110 |         self.slice_mut(0, <cubecl_core::frontend::NativeExpand<usize> as Into<_>>::into(self.len()))
[INFO] [stdout]     |                           ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++          +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&tensor::r#virtual::VirtualTensorExpand<E, N, IO>`
[INFO] [stdout]    --> src/tensor/virtual.rs:165:20
[INFO] [stdout]     |
[INFO] [stdout] 165 |     pub fn as_view(&self) -> View<'_, Vector<E, N>, usize> {
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 165 |     pub fn as_view(<&tensor::r#virtual::VirtualTensorExpand<E, N, IO> as Into<_>>::into(&self)) -> View<'_, Vector<E, N>, usize> {
[INFO] [stdout]     |                    +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]    --> src/tensor/virtual.rs:166:13
[INFO] [stdout]     |
[INFO] [stdout] 166 |         let vector_size = self.vector_size();
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 166 |         let <usize as Into<_>>::into(vector_size) = self.vector_size();
[INFO] [stdout]     |             +++++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]    --> src/tensor/virtual.rs:241:13
[INFO] [stdout]     |
[INFO] [stdout] 241 |         let vector_size = self.vector_size();
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 241 |         let <usize as Into<_>>::into(vector_size) = self.vector_size();
[INFO] [stdout]     |             +++++++++++++++++++++++++           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&mut tensor::r#virtual::VirtualTensorExpand<E, N, cubecl_core::frontend::ReadWrite>`
[INFO] [stdout]    --> src/tensor/virtual.rs:240:24
[INFO] [stdout]     |
[INFO] [stdout] 240 |     pub fn as_view_mut(&mut self) -> ViewMut<'_, Vector<E, N>, usize> {
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 240 |     pub fn as_view_mut(<&mut tensor::r#virtual::VirtualTensorExpand<E, N, cubecl_core::frontend::ReadWrite> as Into<_>>::into(&mut self)) -> ViewMut<'_, Vector<E, N>, usize> {
[INFO] [stdout]     |                        +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++         +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<usize>`
[INFO] [stdout]    --> src/tensor/virtual.rs:249:44
[INFO] [stdout]     |
[INFO] [stdout] 249 |     pub fn coordinate(&self, index: usize, dim: usize) -> usize {
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 249 |     pub fn coordinate(&self, index: usize, <cubecl_core::frontend::NativeExpand<usize> as Into<_>>::into(dim): usize) -> usize {
[INFO] [stdout]     |                                            ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `MatrixIdent`
[INFO] [stdout]   --> src/throughput/runners/compute_cmma.rs:62:9
[INFO] [stdout]    |
[INFO] [stdout] 62 |         cmma::MatrixIdent::A,
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 62 |         <MatrixIdent as Into<_>>::into(cmma::MatrixIdent::A),
[INFO] [stdout]    |         +++++++++++++++++++++++++++++++                    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]   --> src/throughput/runners/compute_cmma.rs:59:20
[INFO] [stdout]    |
[INFO] [stdout] 59 |     let CmmaDims { m, n, k } = cmm_dims;
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 59 |     let CmmaDims { <usize as Into<_>>::into(m), n, k } = cmm_dims;
[INFO] [stdout]    |                    +++++++++++++++++++++++++ +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]   --> src/throughput/runners/compute_cmma.rs:59:23
[INFO] [stdout]    |
[INFO] [stdout] 59 |     let CmmaDims { m, n, k } = cmm_dims;
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 59 |     let CmmaDims { m, <usize as Into<_>>::into(n), k } = cmm_dims;
[INFO] [stdout]    |                       +++++++++++++++++++++++++ +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]   --> src/throughput/runners/compute_cmma.rs:59:26
[INFO] [stdout]    |
[INFO] [stdout] 59 |     let CmmaDims { m, n, k } = cmm_dims;
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 59 |     let CmmaDims { m, n, <usize as Into<_>>::into(k) } = cmm_dims;
[INFO] [stdout]    |                          +++++++++++++++++++++++++ +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `MatrixLayout`
[INFO] [stdout]   --> src/throughput/runners/compute_cmma.rs:66:9
[INFO] [stdout]    |
[INFO] [stdout] 66 |         cmma::MatrixLayout::RowMajor,
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 66 |         <MatrixLayout as Into<_>>::into(cmma::MatrixLayout::RowMajor),
[INFO] [stdout]    |         ++++++++++++++++++++++++++++++++                            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<I>`
[INFO] [stdout]   --> src/throughput/runners/compute_cmma.rs:67:9
[INFO] [stdout]    |
[INFO] [stdout] 67 |         I::cast_from(1),
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 67 |         <cubecl_core::frontend::NativeExpand<I> as Into<_>>::into(I::cast_from(1)),
[INFO] [stdout]    |         ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++               +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `MatrixIdent`
[INFO] [stdout]   --> src/throughput/runners/compute_cmma.rs:71:9
[INFO] [stdout]    |
[INFO] [stdout] 71 |         cmma::MatrixIdent::B,
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 71 |         <MatrixIdent as Into<_>>::into(cmma::MatrixIdent::B),
[INFO] [stdout]    |         +++++++++++++++++++++++++++++++                    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `MatrixLayout`
[INFO] [stdout]   --> src/throughput/runners/compute_cmma.rs:75:9
[INFO] [stdout]    |
[INFO] [stdout] 75 |         cmma::MatrixLayout::ColMajor,
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 75 |         <MatrixLayout as Into<_>>::into(cmma::MatrixLayout::ColMajor),
[INFO] [stdout]    |         ++++++++++++++++++++++++++++++++                            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<I>`
[INFO] [stdout]   --> src/throughput/runners/compute_cmma.rs:76:9
[INFO] [stdout]    |
[INFO] [stdout] 76 |         I::cast_from(1),
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 76 |         <cubecl_core::frontend::NativeExpand<I> as Into<_>>::into(I::cast_from(1)),
[INFO] [stdout]    |         ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++               +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `MatrixIdent`
[INFO] [stdout]   --> src/throughput/runners/compute_cmma.rs:80:9
[INFO] [stdout]    |
[INFO] [stdout] 80 |         cmma::MatrixIdent::Accumulator,
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 80 |         <MatrixIdent as Into<_>>::into(cmma::MatrixIdent::Accumulator),
[INFO] [stdout]    |         +++++++++++++++++++++++++++++++                              +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `MatrixLayout`
[INFO] [stdout]   --> src/throughput/runners/compute_cmma.rs:84:9
[INFO] [stdout]    |
[INFO] [stdout] 84 |         cmma::MatrixLayout::Undefined,
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 84 |         <MatrixLayout as Into<_>>::into(cmma::MatrixLayout::Undefined),
[INFO] [stdout]    |         ++++++++++++++++++++++++++++++++                             +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<ACC>`
[INFO] [stdout]   --> src/throughput/runners/compute_cmma.rs:85:9
[INFO] [stdout]    |
[INFO] [stdout] 85 |         ACC::cast_from(0.0),
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 85 |         <cubecl_core::frontend::NativeExpand<ACC> as Into<_>>::into(ACC::cast_from(0.0)),
[INFO] [stdout]    |         ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++                   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&mut cubecl_core::frontend::NativeExpand<[cubecl_core::frontend::Vector<ACC, N>]>`
[INFO] [stdout]   --> src/throughput/runners/compute_cmma.rs:53:5
[INFO] [stdout]    |
[INFO] [stdout] 53 |     output: &mut [Vector<ACC, N>],
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 53 |     <&mut cubecl_core::frontend::NativeExpand<[cubecl_core::frontend::Vector<ACC, N>]> as Into<_>>::into(output): &mut [Vector<ACC, N>],
[INFO] [stdout]    |     +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `MatrixLayout`
[INFO] [stdout]   --> src/throughput/runners/compute_cmma.rs:93:45
[INFO] [stdout]    |
[INFO] [stdout] 93 |         cmma::store(output, &acc, n as u32, cmma::MatrixLayout::RowMajor);
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 93 |         cmma::store(output, &acc, n as u32, <MatrixLayout as Into<_>>::into(cmma::MatrixLayout::RowMajor));
[INFO] [stdout]    |                                             ++++++++++++++++++++++++++++++++                            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]   --> src/throughput/runners/compute_direct.rs:73:9
[INFO] [stdout]    |
[INFO] [stdout] 73 |     for lane in 0..lanes {
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 73 |     for <usize as Into<_>>::into(lane) in 0..lanes {
[INFO] [stdout]    |         +++++++++++++++++++++++++    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<cubecl_core::frontend::Vector<I, N>>`
[INFO] [stdout]   --> src/throughput/runners/compute_direct.rs:65:13
[INFO] [stdout]    |
[INFO] [stdout] 65 |     let mut s0 = Vector::<I, N>::empty();
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 65 |     let mut <cubecl_core::frontend::NativeExpand<cubecl_core::frontend::Vector<I, N>> as Into<_>>::into(s0) = Vector::<I, N>::empty();
[INFO] [stdout]    |             ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<cubecl_core::frontend::Vector<I, N>>`
[INFO] [stdout]   --> src/throughput/runners/compute_direct.rs:62:13
[INFO] [stdout]    |
[INFO] [stdout] 62 |     let mut b = Vector::<I, N>::empty();
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 62 |     let mut <cubecl_core::frontend::NativeExpand<cubecl_core::frontend::Vector<I, N>> as Into<_>>::into(b) = Vector::<I, N>::empty();
[INFO] [stdout]    |             ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<cubecl_core::frontend::Vector<I, N>>`
[INFO] [stdout]   --> src/throughput/runners/compute_direct.rs:63:13
[INFO] [stdout]    |
[INFO] [stdout] 63 |     let mut c = Vector::<I, N>::empty();
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 63 |     let mut <cubecl_core::frontend::NativeExpand<cubecl_core::frontend::Vector<I, N>> as Into<_>>::into(c) = Vector::<I, N>::empty();
[INFO] [stdout]    |             ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `bool`
[INFO] [stdout]   --> src/throughput/runners/compute_direct.rs:57:17
[INFO] [stdout]    |
[INFO] [stdout] 57 |     #[comptime] use_fma: bool,
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 57 |     #[comptime] <bool as Into<_>>::into(use_fma): bool,
[INFO] [stdout]    |                 ++++++++++++++++++++++++       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<cubecl_core::frontend::Vector<I, N>>`
[INFO] [stdout]   --> src/throughput/runners/compute_direct.rs:66:13
[INFO] [stdout]    |
[INFO] [stdout] 66 |     let mut s1 = Vector::<I, N>::empty();
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 66 |     let mut <cubecl_core::frontend::NativeExpand<cubecl_core::frontend::Vector<I, N>> as Into<_>>::into(s1) = Vector::<I, N>::empty();
[INFO] [stdout]    |             ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<cubecl_core::frontend::Vector<I, N>>`
[INFO] [stdout]   --> src/throughput/runners/compute_direct.rs:67:13
[INFO] [stdout]    |
[INFO] [stdout] 67 |     let mut s2 = Vector::<I, N>::empty();
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 67 |     let mut <cubecl_core::frontend::NativeExpand<cubecl_core::frontend::Vector<I, N>> as Into<_>>::into(s2) = Vector::<I, N>::empty();
[INFO] [stdout]    |             ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<cubecl_core::frontend::Vector<I, N>>`
[INFO] [stdout]   --> src/throughput/runners/compute_direct.rs:68:13
[INFO] [stdout]    |
[INFO] [stdout] 68 |     let mut s3 = Vector::<I, N>::empty();
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 68 |     let mut <cubecl_core::frontend::NativeExpand<cubecl_core::frontend::Vector<I, N>> as Into<_>>::into(s3) = Vector::<I, N>::empty();
[INFO] [stdout]    |             ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++  +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<cubecl_core::frontend::Vector<I, N>>`
[INFO] [stdout]    --> src/throughput/runners/compute_direct.rs:102:5
[INFO] [stdout]     |
[INFO] [stdout] 102 |     s: Vector<I, N>,
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 102 |     <cubecl_core::frontend::NativeExpand<cubecl_core::frontend::Vector<I, N>> as Into<_>>::into(s): Vector<I, N>,
[INFO] [stdout]     |     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<cubecl_core::frontend::Vector<I, N>>`
[INFO] [stdout]    --> src/throughput/runners/compute_direct.rs:103:5
[INFO] [stdout]     |
[INFO] [stdout] 103 |     b: Vector<I, N>,
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 103 |     <cubecl_core::frontend::NativeExpand<cubecl_core::frontend::Vector<I, N>> as Into<_>>::into(b): Vector<I, N>,
[INFO] [stdout]     |     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<cubecl_core::frontend::Vector<I, N>>`
[INFO] [stdout]    --> src/throughput/runners/compute_direct.rs:104:5
[INFO] [stdout]     |
[INFO] [stdout] 104 |     c: Vector<I, N>,
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 104 |     <cubecl_core::frontend::NativeExpand<cubecl_core::frontend::Vector<I, N>> as Into<_>>::into(c): Vector<I, N>,
[INFO] [stdout]     |     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++ +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<usize>`
[INFO] [stdout]   --> src/throughput/runners/memory_direct.rs:71:9
[INFO] [stdout]    |
[INFO] [stdout] 71 |     let stride = CUBE_DIM as usize * CUBE_COUNT;
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 71 |     let <cubecl_core::frontend::NativeExpand<usize> as Into<_>>::into(stride) = CUBE_DIM as usize * CUBE_COUNT;
[INFO] [stdout]    |         ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<usize>`
[INFO] [stdout]    --> src/throughput/runners/memory_probe.rs:222:9
[INFO] [stdout]     |
[INFO] [stdout] 222 |     let stride = CUBE_DIM as usize * CUBE_COUNT;
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 222 |     let <cubecl_core::frontend::NativeExpand<usize> as Into<_>>::into(stride) = CUBE_DIM as usize * CUBE_COUNT;
[INFO] [stdout]     |         ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<usize>`
[INFO] [stdout]   --> src/throughput/runners/memory_read.rs:84:9
[INFO] [stdout]    |
[INFO] [stdout] 84 |     let stride = CUBE_DIM as usize * CUBE_COUNT;
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 84 |     let <cubecl_core::frontend::NativeExpand<usize> as Into<_>>::into(stride) = CUBE_DIM as usize * CUBE_COUNT;
[INFO] [stdout]    |         ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]   --> src/throughput/runners/memory_read.rs:97:9
[INFO] [stdout]    |
[INFO] [stdout] 97 |     for lane in 0..lanes {
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 97 |     for <usize as Into<_>>::into(lane) in 0..lanes {
[INFO] [stdout]    |         +++++++++++++++++++++++++    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<I>`
[INFO] [stdout]   --> src/throughput/runners/memory_read.rs:98:26
[INFO] [stdout]    |
[INFO] [stdout] 98 |         acc.insert(lane, I::cast_from(0));
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 98 |         acc.insert(lane, <cubecl_core::frontend::NativeExpand<I> as Into<_>>::into(I::cast_from(0)));
[INFO] [stdout]    |                          ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++               +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<usize>`
[INFO] [stdout]   --> src/throughput/runners/memory_write.rs:77:9
[INFO] [stdout]    |
[INFO] [stdout] 77 |     let stride = CUBE_DIM as usize * CUBE_COUNT;
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 77 |     let <cubecl_core::frontend::NativeExpand<usize> as Into<_>>::into(stride) = CUBE_DIM as usize * CUBE_COUNT;
[INFO] [stdout]    |         ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `cubecl_core::frontend::NativeExpand<usize>`
[INFO] [stdout]   --> src/throughput/runners/memory_write.rs:72:5
[INFO] [stdout]    |
[INFO] [stdout] 72 |     n_iter: usize,
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 72 |     <cubecl_core::frontend::NativeExpand<usize> as Into<_>>::into(n_iter): usize,
[INFO] [stdout]    |     ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `usize`
[INFO] [stdout]   --> src/throughput/runners/memory_write.rs:93:9
[INFO] [stdout]    |
[INFO] [stdout] 93 |     for lane in 0..lanes {
[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: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 93 |     for <usize as Into<_>>::into(lane) in 0..lanes {
[INFO] [stdout]    |         +++++++++++++++++++++++++    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `cubecl-std` (lib test) due to 184 previous errors
[INFO] running `Command { std: "docker" "inspect" "29c48db805e442ee715d83640f532063472b5a6f5a78c013b623ad030e6947d8", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "29c48db805e442ee715d83640f532063472b5a6f5a78c013b623ad030e6947d8", kill_on_drop: false }`
[INFO] [stdout] 29c48db805e442ee715d83640f532063472b5a6f5a78c013b623ad030e6947d8
