[INFO] fetching crate ug 0.5.0...
[INFO] checking ug-0.5.0 against 52995a223f2919dd3e2e427231db90a257350ded for pr-129249-4
[INFO] extracting crate ug 0.5.0 into /workspace/builds/worker-7-tc2/source
[INFO] started tweaking crates.io crate ug 0.5.0
[INFO] removed 0 missing examples
[INFO] removed 0 missing tests
[INFO] finished tweaking crates.io crate ug 0.5.0
[INFO] tweaked toml for crates.io crate ug 0.5.0 written to /workspace/builds/worker-7-tc2/source/Cargo.toml
[INFO] validating manifest of crates.io crate ug 0.5.0 on toolchain 52995a223f2919dd3e2e427231db90a257350ded
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+52995a223f2919dd3e2e427231db90a257350ded" "metadata" "--manifest-path" "Cargo.toml" "--no-deps", kill_on_drop: false }`
[INFO] crate crates.io crate ug 0.5.0 already has a lockfile, it will not be regenerated
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+52995a223f2919dd3e2e427231db90a257350ded" "fetch" "--manifest-path" "Cargo.toml", kill_on_drop: false }`
[INFO] [stderr]     Blocking waiting for file lock on package cache
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-7-tc2/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-7-tc2/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/cargo-home:/opt/rustwide/cargo-home:ro,Z" "-v" "/var/lib/crater-agent-workspace/rustup-home:/opt/rustwide/rustup-home:ro,Z" "-m" "1610612736" "--network" "none" "ghcr.io/rust-lang/crates-build-env/linux@sha256:c0af3998e971868164375a7dfb646c9933ddd1a3bdb00fa2041266763dc1eeab" "sleep" "infinity", kill_on_drop: false }`
[INFO] [stdout] 90ff1ec0a00f6e8db94c3e50d72b958cef409645a9d41fe66b7e2d0d719ae206
[INFO] running `Command { std: "docker" "start" "90ff1ec0a00f6e8db94c3e50d72b958cef409645a9d41fe66b7e2d0d719ae206", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "90ff1ec0a00f6e8db94c3e50d72b958cef409645a9d41fe66b7e2d0d719ae206", 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" "90ff1ec0a00f6e8db94c3e50d72b958cef409645a9d41fe66b7e2d0d719ae206" "/opt/rustwide/cargo-home/bin/cargo" "+52995a223f2919dd3e2e427231db90a257350ded" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "90ff1ec0a00f6e8db94c3e50d72b958cef409645a9d41fe66b7e2d0d719ae206", 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" "90ff1ec0a00f6e8db94c3e50d72b958cef409645a9d41fe66b7e2d0d719ae206" "/opt/rustwide/cargo-home/bin/cargo" "+52995a223f2919dd3e2e427231db90a257350ded" "check" "--frozen" "--all" "--all-targets" "--message-format=json", kill_on_drop: false }`
[INFO] [stderr]    Compiling proc-macro2 v1.0.87
[INFO] [stderr]    Compiling seq-macro v0.3.5
[INFO] [stderr]    Compiling libc v0.2.159
[INFO] [stderr]    Compiling serde v1.0.210
[INFO] [stderr]     Checking raw-cpuid v10.7.0
[INFO] [stderr]    Compiling serde_json v1.0.132
[INFO] [stderr]     Checking stable_deref_trait v1.2.0
[INFO] [stderr]     Checking ryu v1.0.18
[INFO] [stderr]     Checking num-traits v0.2.19
[INFO] [stderr]    Compiling quote v1.0.37
[INFO] [stderr]     Checking rand_distr v0.4.3
[INFO] [stderr]     Checking num-integer v0.1.46
[INFO] [stderr]    Compiling syn v2.0.79
[INFO] [stderr]     Checking num-bigint v0.4.6
[INFO] [stderr]     Checking num-iter v0.1.45
[INFO] [stderr]     Checking num_cpus v1.16.0
[INFO] [stderr]     Checking memmap2 v0.9.5
[INFO] [stderr]     Checking num-rational v0.4.2
[INFO] [stderr]    Compiling synstructure v0.13.1
[INFO] [stderr]    Compiling bytemuck_derive v1.8.0
[INFO] [stderr]    Compiling serde_derive v1.0.210
[INFO] [stderr]    Compiling zerofrom-derive v0.1.4
[INFO] [stderr]    Compiling thiserror-impl v1.0.65
[INFO] [stderr]    Compiling tracing-attributes v0.1.27
[INFO] [stderr]    Compiling yoke-derive v0.7.4
[INFO] [stderr]     Checking thiserror v1.0.65
[INFO] [stderr]     Checking zerofrom v0.1.4
[INFO] [stderr]     Checking tracing v0.1.40
[INFO] [stderr]     Checking yoke v0.7.4
[INFO] [stderr]     Checking bytemuck v1.19.0
[INFO] [stderr]     Checking num-complex v0.4.6
[INFO] [stderr]     Checking dyn-stack v0.10.0
[INFO] [stderr]     Checking half v2.4.1
[INFO] [stderr]     Checking pulp v0.18.22
[INFO] [stderr]     Checking num v0.4.3
[INFO] [stderr]     Checking gemm-common v0.18.0
[INFO] [stderr]     Checking gemm-f32 v0.18.0
[INFO] [stderr]     Checking gemm-c64 v0.18.0
[INFO] [stderr]     Checking gemm-c32 v0.18.0
[INFO] [stderr]     Checking gemm-f64 v0.18.0
[INFO] [stderr]     Checking gemm-f16 v0.18.0
[INFO] [stderr]     Checking gemm v0.18.0
[INFO] [stderr]     Checking safetensors v0.4.5
[INFO] [stderr]     Checking ug v0.5.0 (/opt/rustwide/workdir)
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/block.rs:153:25
[INFO] [stdout]     |
[INFO] [stdout] 153 |                 None => crate::bail!("id not found {id:?}"),
[INFO] [stdout]     |                         ----------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout]     = note: `#[deny(self_type_conversion)]` on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]   --> src/error.rs:92:39
[INFO] [stdout]    |
[INFO] [stdout] 90 | macro_rules! bail {
[INFO] [stdout] 91 |     ($msg:literal $(,)?) => {
[INFO] [stdout] 92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]    |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/cache.rs:19:33
[INFO] [stdout]    |
[INFO] [stdout] 19 |                 A::Id { .. } => crate::bail!("unexpected id node"),
[INFO] [stdout]    |                                 ---------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]   --> src/error.rs:92:39
[INFO] [stdout]    |
[INFO] [stdout] 90 | macro_rules! bail {
[INFO] [stdout] 91 |     ($msg:literal $(,)?) => {
[INFO] [stdout] 92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]    |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/cache.rs:22:33
[INFO] [stdout]    |
[INFO] [stdout] 22 |                         None => crate::bail!("BUG: missing arg id {src:?}"),
[INFO] [stdout]    |                                 ------------------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]   --> src/error.rs:92:39
[INFO] [stdout]    |
[INFO] [stdout] 90 | macro_rules! bail {
[INFO] [stdout] 91 |     ($msg:literal $(,)?) => {
[INFO] [stdout] 92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]    |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/cache.rs:64:25
[INFO] [stdout]    |
[INFO] [stdout] 64 |                 None => crate::bail!("BUG: missing arg id {dst:?}"),
[INFO] [stdout]    |                         ------------------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]   --> src/error.rs:92:39
[INFO] [stdout]    |
[INFO] [stdout] 90 | macro_rules! bail {
[INFO] [stdout] 91 |     ($msg:literal $(,)?) => {
[INFO] [stdout] 92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]    |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/const.rs:96:13
[INFO] [stdout]    |
[INFO] [stdout] 96 |             crate::bail!("cannot use nan in const")
[INFO] [stdout]    |             --------------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/const.rs:106:13
[INFO] [stdout]     |
[INFO] [stdout] 106 |             crate::bail!("cannot use nan in const")
[INFO] [stdout]     |             --------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/const.rs:128:13
[INFO] [stdout]     |
[INFO] [stdout] 128 |             crate::bail!("cannot use nan in const")
[INFO] [stdout]     |             --------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]   --> src/error.rs:92:39
[INFO] [stdout]    |
[INFO] [stdout] 90 | macro_rules! bail {
[INFO] [stdout] 91 |     ($msg:literal $(,)?) => {
[INFO] [stdout] 92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]    |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/cpu_code_gen.rs:72:9
[INFO] [stdout]    |
[INFO] [stdout] 72 |         bail!("TODO: add the reduce code if needed")
[INFO] [stdout]    |         -------------------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/cpu_code_gen.rs:120:21
[INFO] [stdout]     |
[INFO] [stdout] 120 |                     bail!("unmatched EndRange")
[INFO] [stdout]     |                     --------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/cpu_code_gen.rs:162:17
[INFO] [stdout]     |
[INFO] [stdout] 162 |                 bail!("thread-id is currently not supported in the cpu backend")
[INFO] [stdout]     |                 ---------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/cpu_code_gen.rs:166:17
[INFO] [stdout]     |
[INFO] [stdout] 166 |                 bail!("block-id is currently not supported in the cpu backend")
[INFO] [stdout]     |                 --------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/cpu_code_gen.rs:183:9
[INFO] [stdout]     |
[INFO] [stdout] 183 |         bail!("unmatched Range")
[INFO] [stdout]     |         ------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:98:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout] ...
[INFO] [stdout]  98 |         return Err($crate::Error::Msg(format!($fmt, $($arg)*).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/cpu_runtime.rs:331:18
[INFO] [stdout]     |
[INFO] [stdout] 331 |             _ => crate::bail!("unsupported number of args for kernel {}", args.len()),
[INFO] [stdout]     |                  -------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 |   macro_rules! bail {
[INFO] [stdout]  91 |       ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |           return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                         ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/cpu_runtime.rs:352:17
[INFO] [stdout]     |
[INFO] [stdout] 352 | /                 crate::bail!(
[INFO] [stdout] 353 | |                     "incorrect dtypes for matmul, dst: {dst_dt:?}, lhs: {lhs_dt:?}, rhs: {rhs_dt:?}"
[INFO] [stdout] 354 | |                 )
[INFO] [stdout]     | |_________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:98:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout] ...
[INFO] [stdout]  98 |         return Err($crate::Error::Msg(format!($fmt, $($arg)*).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/cpu_runtime.rs:381:13
[INFO] [stdout]     |
[INFO] [stdout] 381 |             crate::bail!("dtoh len mismatch, dst {}, len {}", self.len(), src.len())
[INFO] [stdout]     |             ------------------------------------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:98:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout] ...
[INFO] [stdout]  98 |         return Err($crate::Error::Msg(format!($fmt, $($arg)*).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/cpu_runtime.rs:390:17
[INFO] [stdout]     |
[INFO] [stdout] 390 |                 crate::bail!("htod dtype mismatch, dst {dtype:?}, src {:?}", DT::DTYPE)
[INFO] [stdout]     |                 ----------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:98:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout] ...
[INFO] [stdout]  98 |         return Err($crate::Error::Msg(format!($fmt, $($arg)*).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/cpu_runtime.rs:401:13
[INFO] [stdout]     |
[INFO] [stdout] 401 |             crate::bail!("dtoh len mismatch, dst {}, len {}", dst.len(), self.len())
[INFO] [stdout]     |             ------------------------------------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:98:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout] ...
[INFO] [stdout]  98 |         return Err($crate::Error::Msg(format!($fmt, $($arg)*).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/cpu_runtime.rs:409:23
[INFO] [stdout]     |
[INFO] [stdout] 409 |             (_, _) => crate::bail!("dtoh dtype mismatch, dst {:?}, src {dtype:?}", DT::DTYPE),
[INFO] [stdout]     |                       ----------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:98:39
[INFO] [stdout]     |
[INFO] [stdout]  90 |   macro_rules! bail {
[INFO] [stdout] ...
[INFO] [stdout]  98 |           return Err($crate::Error::Msg(format!($fmt, $($arg)*).into()).bt())
[INFO] [stdout]     |                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/cpu_runtime.rs:491:17
[INFO] [stdout]     |
[INFO] [stdout] 491 | /                 crate::bail!(
[INFO] [stdout] 492 | |                     "compilation failed\nstdout:\n{}\nstderr:{}",
[INFO] [stdout] 493 | |                     String::from_utf8_lossy(&output.stdout),
[INFO] [stdout] 494 | |                     String::from_utf8_lossy(&output.stderr)
[INFO] [stdout] 495 | |                 )
[INFO] [stdout]     | |_________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/cpu_runtime.rs:563:18
[INFO] [stdout]     |
[INFO] [stdout] 563 |             _ => crate::bail!("unsupported dtype for gemm"),
[INFO] [stdout]     |                  ------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:98:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | / macro_rules! bail {
[INFO] [stdout]  91 | |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 | |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]  93 | |     };
[INFO] [stdout] ...   |
[INFO] [stdout]  98 | |         return Err($crate::Error::Msg(format!($fmt, $($arg)*).into()).bt())
[INFO] [stdout]     | |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]  99 | |     };
[INFO] [stdout] 100 | | }
[INFO] [stdout]     | |_- this error originates in the macro `bail` which comes from the expansion of the macro `with_dtype`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/dtype.rs:125:1
[INFO] [stdout]     |
[INFO] [stdout] 125 |   with_dtype!(bf16, BF16);
[INFO] [stdout]     |   ----------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:98:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | / macro_rules! bail {
[INFO] [stdout]  91 | |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 | |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]  93 | |     };
[INFO] [stdout] ...   |
[INFO] [stdout]  98 | |         return Err($crate::Error::Msg(format!($fmt, $($arg)*).into()).bt())
[INFO] [stdout]     | |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]  99 | |     };
[INFO] [stdout] 100 | | }
[INFO] [stdout]     | |_- this error originates in the macro `bail` which comes from the expansion of the macro `with_dtype`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/dtype.rs:125:1
[INFO] [stdout]     |
[INFO] [stdout] 125 |   with_dtype!(bf16, BF16);
[INFO] [stdout]     |   ----------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:98:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | / macro_rules! bail {
[INFO] [stdout]  91 | |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 | |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]  93 | |     };
[INFO] [stdout] ...   |
[INFO] [stdout]  98 | |         return Err($crate::Error::Msg(format!($fmt, $($arg)*).into()).bt())
[INFO] [stdout]     | |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]  99 | |     };
[INFO] [stdout] 100 | | }
[INFO] [stdout]     | |_- this error originates in the macro `bail` which comes from the expansion of the macro `with_dtype`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/dtype.rs:126:1
[INFO] [stdout]     |
[INFO] [stdout] 126 |   with_dtype!(f16, F16);
[INFO] [stdout]     |   --------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:98:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | / macro_rules! bail {
[INFO] [stdout]  91 | |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 | |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]  93 | |     };
[INFO] [stdout] ...   |
[INFO] [stdout]  98 | |         return Err($crate::Error::Msg(format!($fmt, $($arg)*).into()).bt())
[INFO] [stdout]     | |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]  99 | |     };
[INFO] [stdout] 100 | | }
[INFO] [stdout]     | |_- this error originates in the macro `bail` which comes from the expansion of the macro `with_dtype`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/dtype.rs:126:1
[INFO] [stdout]     |
[INFO] [stdout] 126 |   with_dtype!(f16, F16);
[INFO] [stdout]     |   --------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:98:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | / macro_rules! bail {
[INFO] [stdout]  91 | |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 | |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]  93 | |     };
[INFO] [stdout] ...   |
[INFO] [stdout]  98 | |         return Err($crate::Error::Msg(format!($fmt, $($arg)*).into()).bt())
[INFO] [stdout]     | |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]  99 | |     };
[INFO] [stdout] 100 | | }
[INFO] [stdout]     | |_- this error originates in the macro `bail` which comes from the expansion of the macro `with_dtype`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/dtype.rs:127:1
[INFO] [stdout]     |
[INFO] [stdout] 127 |   with_dtype!(f32, F32);
[INFO] [stdout]     |   --------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:98:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | / macro_rules! bail {
[INFO] [stdout]  91 | |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 | |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]  93 | |     };
[INFO] [stdout] ...   |
[INFO] [stdout]  98 | |         return Err($crate::Error::Msg(format!($fmt, $($arg)*).into()).bt())
[INFO] [stdout]     | |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]  99 | |     };
[INFO] [stdout] 100 | | }
[INFO] [stdout]     | |_- this error originates in the macro `bail` which comes from the expansion of the macro `with_dtype`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/dtype.rs:127:1
[INFO] [stdout]     |
[INFO] [stdout] 127 |   with_dtype!(f32, F32);
[INFO] [stdout]     |   --------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:98:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | / macro_rules! bail {
[INFO] [stdout]  91 | |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 | |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]  93 | |     };
[INFO] [stdout] ...   |
[INFO] [stdout]  98 | |         return Err($crate::Error::Msg(format!($fmt, $($arg)*).into()).bt())
[INFO] [stdout]     | |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]  99 | |     };
[INFO] [stdout] 100 | | }
[INFO] [stdout]     | |_- this error originates in the macro `bail` which comes from the expansion of the macro `with_dtype`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/dtype.rs:128:1
[INFO] [stdout]     |
[INFO] [stdout] 128 |   with_dtype!(i32, I32);
[INFO] [stdout]     |   --------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:98:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | / macro_rules! bail {
[INFO] [stdout]  91 | |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 | |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]  93 | |     };
[INFO] [stdout] ...   |
[INFO] [stdout]  98 | |         return Err($crate::Error::Msg(format!($fmt, $($arg)*).into()).bt())
[INFO] [stdout]     | |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]  99 | |     };
[INFO] [stdout] 100 | | }
[INFO] [stdout]     | |_- this error originates in the macro `bail` which comes from the expansion of the macro `with_dtype`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/dtype.rs:128:1
[INFO] [stdout]     |
[INFO] [stdout] 128 |   with_dtype!(i32, I32);
[INFO] [stdout]     |   --------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:98:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | / macro_rules! bail {
[INFO] [stdout]  91 | |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 | |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]  93 | |     };
[INFO] [stdout] ...   |
[INFO] [stdout]  98 | |         return Err($crate::Error::Msg(format!($fmt, $($arg)*).into()).bt())
[INFO] [stdout]     | |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]  99 | |     };
[INFO] [stdout] 100 | | }
[INFO] [stdout]     | |_- this error originates in the macro `bail` which comes from the expansion of the macro `with_dtype`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/dtype.rs:129:1
[INFO] [stdout]     |
[INFO] [stdout] 129 |   with_dtype!(i64, I64);
[INFO] [stdout]     |   --------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:98:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | / macro_rules! bail {
[INFO] [stdout]  91 | |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 | |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]  93 | |     };
[INFO] [stdout] ...   |
[INFO] [stdout]  98 | |         return Err($crate::Error::Msg(format!($fmt, $($arg)*).into()).bt())
[INFO] [stdout]     | |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]  99 | |     };
[INFO] [stdout] 100 | | }
[INFO] [stdout]     | |_- this error originates in the macro `bail` which comes from the expansion of the macro `with_dtype`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/dtype.rs:129:1
[INFO] [stdout]     |
[INFO] [stdout] 129 |   with_dtype!(i64, I64);
[INFO] [stdout]     |   --------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:125:18
[INFO] [stdout]     |
[INFO] [stdout] 125 |             _ => crate::bail!("unexpected buffer type"),
[INFO] [stdout]     |                  -------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:132:18
[INFO] [stdout]     |
[INFO] [stdout] 132 |             _ => crate::bail!("unexpected buffer type"),
[INFO] [stdout]     |                  -------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:146:13
[INFO] [stdout]     |
[INFO] [stdout] 146 |             crate::bail!("not an i32 {self:?}")
[INFO] [stdout]     |             ----------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:154:13
[INFO] [stdout]     |
[INFO] [stdout] 154 |             crate::bail!("not a f32 {self:?}")
[INFO] [stdout]     |             ---------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:174:21
[INFO] [stdout]     |
[INFO] [stdout] 174 |             None => crate::bail!("set out of bound {id}"),
[INFO] [stdout]     |                     ------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:183:21
[INFO] [stdout]     |
[INFO] [stdout] 183 |             None => crate::bail!("get out of bound {id:?}"),
[INFO] [stdout]     |                     --------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:233:21
[INFO] [stdout]     |
[INFO] [stdout] 233 |                     crate::bail!("diverging threads in warp")
[INFO] [stdout]     |                     ----------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:244:21
[INFO] [stdout]     |
[INFO] [stdout] 244 |                     crate::bail!("get out of bounds {current_idx}")
[INFO] [stdout]     |                     ----------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:262:25
[INFO] [stdout]     |
[INFO] [stdout] 262 |                         crate::bail!("diverging threads in warp")
[INFO] [stdout]     |                         ----------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:286:26
[INFO] [stdout]     |
[INFO] [stdout] 286 |                     _ => crate::bail!("unexpected dtype for src in load {src:?}"),
[INFO] [stdout]     |                          -------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:306:26
[INFO] [stdout]     |
[INFO] [stdout] 306 |                     _ => crate::bail!("unexpected dtype for src in store {dst:?}"),
[INFO] [stdout]     |                          --------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:315:34
[INFO] [stdout]     |
[INFO] [stdout] 315 |                     (None, v) => crate::bail!("no buffer for store {v:?}"),
[INFO] [stdout]     |                                  ----------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:316:31
[INFO] [stdout]     |
[INFO] [stdout] 316 |                     (_, v) => crate::bail!("unexpected dtype for value in store {v:?}"),
[INFO] [stdout]     |                               --------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:327:39
[INFO] [stdout]     |
[INFO] [stdout] 327 |                     (B::Add, _, _) => crate::bail!("dtype mismatch for {op:?}"),
[INFO] [stdout]     |                                       ----------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:330:39
[INFO] [stdout]     |
[INFO] [stdout] 330 |                     (B::Mul, _, _) => crate::bail!("dtype mismatch for {op:?}"),
[INFO] [stdout]     |                                       ----------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:333:39
[INFO] [stdout]     |
[INFO] [stdout] 333 |                     (B::Sub, _, _) => crate::bail!("dtype mismatch for {op:?}"),
[INFO] [stdout]     |                                       ----------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:336:39
[INFO] [stdout]     |
[INFO] [stdout] 336 |                     (B::Div, _, _) => crate::bail!("dtype mismatch for {op:?}"),
[INFO] [stdout]     |                                       ----------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:339:39
[INFO] [stdout]     |
[INFO] [stdout] 339 |                     (B::Mod, _, _) => crate::bail!("dtype mismatch for {op:?}"),
[INFO] [stdout]     |                                       ----------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:342:39
[INFO] [stdout]     |
[INFO] [stdout] 342 |                     (B::Max, _, _) => crate::bail!("dtype mismatch for {op:?}"),
[INFO] [stdout]     |                                       ----------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:345:39
[INFO] [stdout]     |
[INFO] [stdout] 345 |                     (B::Min, _, _) => crate::bail!("dtype mismatch for {op:?}"),
[INFO] [stdout]     |                                       ----------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:356:36
[INFO] [stdout]     |
[INFO] [stdout] 356 |                     (U::Neg, _) => crate::bail!("dtype mismatch for {op:?} {arg:?}"),
[INFO] [stdout]     |                                    ------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:358:36
[INFO] [stdout]     |
[INFO] [stdout] 358 |                     (U::Exp, _) => crate::bail!("dtype mismatch for {op:?} {arg:?}"),
[INFO] [stdout]     |                                    ------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:360:37
[INFO] [stdout]     |
[INFO] [stdout] 360 |                     (U::Sqrt, _) => crate::bail!("dtype mismatch for {op:?} {arg:?}"),
[INFO] [stdout]     |                                     ------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:362:36
[INFO] [stdout]     |
[INFO] [stdout] 362 |                     (U::Sin, _) => crate::bail!("dtype mismatch for {op:?} {arg:?}"),
[INFO] [stdout]     |                                    ------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:364:36
[INFO] [stdout]     |
[INFO] [stdout] 364 |                     (U::Cos, _) => crate::bail!("dtype mismatch for {op:?} {arg:?}"),
[INFO] [stdout]     |                                    ------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:368:30
[INFO] [stdout]     |
[INFO] [stdout] 368 |                         _ => crate::bail!("dtype mismatch for {op:?} {arg:?} {dtype:?}"),
[INFO] [stdout]     |                              ----------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:373:30
[INFO] [stdout]     |
[INFO] [stdout] 373 |                         _ => crate::bail!("dtype mismatch for {op:?} {arg:?} {dtype:?}"),
[INFO] [stdout]     |                              ----------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:375:40
[INFO] [stdout]     |
[INFO] [stdout] 375 |                     (U::Cast(_), _) => crate::bail!("dtype mismatch for {op:?} {arg:?}"),
[INFO] [stdout]     |                                        ------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:410:31
[INFO] [stdout]     |
[INFO] [stdout] 410 |                     (_, _) => crate::bail!("dtype mismatch for {op:?} {arg:?}"),
[INFO] [stdout]     |                               ------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lang.rs:308:36
[INFO] [stdout]     |
[INFO] [stdout] 308 |             ssa::Type::Value(_) => crate::bail!("non-pointer arguments are not supported yet"),
[INFO] [stdout]     |                                    ----------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:98:39
[INFO] [stdout]     |
[INFO] [stdout]  90 |   macro_rules! bail {
[INFO] [stdout] ...
[INFO] [stdout]  98 |           return Err($crate::Error::Msg(format!($fmt, $($arg)*).into()).bt())
[INFO] [stdout]     |                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lang.rs:456:13
[INFO] [stdout]     |
[INFO] [stdout] 456 | /             crate::bail!(
[INFO] [stdout] 457 | |                 "target shape {:?} has less dimensions than original shape {:?}",
[INFO] [stdout] 458 | |                 shape,
[INFO] [stdout] 459 | |                 arg.shape
[INFO] [stdout] 460 | |             )
[INFO] [stdout]     | |_____________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:98:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout] ...
[INFO] [stdout]  98 |         return Err($crate::Error::Msg(format!($fmt, $($arg)*).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lang.rs:470:21
[INFO] [stdout]     |
[INFO] [stdout] 470 |                     crate::bail!("cannot broadcast from {:?} to {shape:?}", arg.shape)
[INFO] [stdout]     |                     ------------------------------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lang.rs:500:13
[INFO] [stdout]     |
[INFO] [stdout] 500 |             crate::bail!("no dim {dim} in shape {shape:?}")
[INFO] [stdout]     |             ----------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:98:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout] ...
[INFO] [stdout]  98 |         return Err($crate::Error::Msg(format!($fmt, $($arg)*).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lang.rs:509:13
[INFO] [stdout]     |
[INFO] [stdout] 509 |             crate::bail!("dtype mismatch in {op:?}, lhs: {:?}, rhs: {:?}", lhs.dtype, rhs.dtype)
[INFO] [stdout]     |             ------------------------------------------------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:98:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout] ...
[INFO] [stdout]  98 |         return Err($crate::Error::Msg(format!($fmt, $($arg)*).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lang.rs:515:13
[INFO] [stdout]     |
[INFO] [stdout] 515 |             crate::bail!("shape mismatch in {op:?}, lhs: {:?}, rhs: {:?}", lhs.shape, rhs.shape)
[INFO] [stdout]     |             ------------------------------------------------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lang.rs:531:23
[INFO] [stdout]     |
[INFO] [stdout] 531 |             Err(_) => crate::bail!("unable to create const for {v:?}"),
[INFO] [stdout]     |                       ------------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/block.rs:153:25
[INFO] [stdout]     |
[INFO] [stdout] 153 |                 None => crate::bail!("id not found {id:?}"),
[INFO] [stdout]     |                         ----------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout]     = note: `#[deny(self_type_conversion)]` on by default
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]   --> src/error.rs:92:39
[INFO] [stdout]    |
[INFO] [stdout] 90 | macro_rules! bail {
[INFO] [stdout] 91 |     ($msg:literal $(,)?) => {
[INFO] [stdout] 92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]    |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/cache.rs:19:33
[INFO] [stdout]    |
[INFO] [stdout] 19 |                 A::Id { .. } => crate::bail!("unexpected id node"),
[INFO] [stdout]    |                                 ---------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]   --> src/error.rs:92:39
[INFO] [stdout]    |
[INFO] [stdout] 90 | macro_rules! bail {
[INFO] [stdout] 91 |     ($msg:literal $(,)?) => {
[INFO] [stdout] 92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]    |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/cache.rs:22:33
[INFO] [stdout]    |
[INFO] [stdout] 22 |                         None => crate::bail!("BUG: missing arg id {src:?}"),
[INFO] [stdout]    |                                 ------------------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lang.rs:744:25
[INFO] [stdout]     |
[INFO] [stdout] 744 |                         crate::bail!("unexpected order for arguments in kernel {instrs:?}")
[INFO] [stdout]     |                         ------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]   --> src/error.rs:92:39
[INFO] [stdout]    |
[INFO] [stdout] 90 | macro_rules! bail {
[INFO] [stdout] 91 |     ($msg:literal $(,)?) => {
[INFO] [stdout] 92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]    |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/cache.rs:64:25
[INFO] [stdout]    |
[INFO] [stdout] 64 |                 None => crate::bail!("BUG: missing arg id {dst:?}"),
[INFO] [stdout]    |                         ------------------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lang.rs:772:33
[INFO] [stdout]     |
[INFO] [stdout] 772 | ...                   crate::bail!("range lo is not a const i32/i64")
[INFO] [stdout]     |                       ----------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lang.rs:777:38
[INFO] [stdout]     |
[INFO] [stdout] 777 | ...                   _ => crate::bail!("range lo is not a const"),
[INFO] [stdout]     |                            --------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lang.rs:784:33
[INFO] [stdout]     |
[INFO] [stdout] 784 | ...                   crate::bail!("range up is not a const i32/i64")
[INFO] [stdout]     |                       ----------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]   --> src/error.rs:92:39
[INFO] [stdout]    |
[INFO] [stdout] 90 | macro_rules! bail {
[INFO] [stdout] 91 |     ($msg:literal $(,)?) => {
[INFO] [stdout] 92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]    |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/const.rs:96:13
[INFO] [stdout]    |
[INFO] [stdout] 96 |             crate::bail!("cannot use nan in const")
[INFO] [stdout]    |             --------------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lang.rs:789:38
[INFO] [stdout]     |
[INFO] [stdout] 789 | ...                   _ => crate::bail!("range lo is not a const"),
[INFO] [stdout]     |                            --------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lang.rs:795:33
[INFO] [stdout]     |
[INFO] [stdout] 795 |                         None => crate::bail!("unexpected EndRange"),
[INFO] [stdout]     |                                 ----------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/const.rs:106:13
[INFO] [stdout]     |
[INFO] [stdout] 106 |             crate::bail!("cannot use nan in const")
[INFO] [stdout]     |             --------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/layout.rs:219:17
[INFO] [stdout]     |
[INFO] [stdout] 219 |                 bail!("shape mismatch in binary op '{op}', lhs: {lhs:?} rhs: {rhs:?}")
[INFO] [stdout]     |                 ---------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/layout.rs:235:13
[INFO] [stdout]     |
[INFO] [stdout] 235 |             bail!("dim out of range in '{op}', dim: {dim}, shape: {shape:?}")
[INFO] [stdout]     |             ----------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/layout.rs:243:13
[INFO] [stdout]     |
[INFO] [stdout] 243 |             bail!("dim out of range in '{op}', dim: {dim}, shape: {shape:?}")
[INFO] [stdout]     |             ----------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/layout.rs:316:17
[INFO] [stdout]     |
[INFO] [stdout] 316 |                 bail!("duplicate dim indexes in '{op}', dims: {dims:?}, shape: {shape:?}")
[INFO] [stdout]     |                 -------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/layout.rs:319:17
[INFO] [stdout]     |
[INFO] [stdout] 319 |                 bail!("dim out of range in '{op}', dim: {dim}, shape: {shape:?}")
[INFO] [stdout]     |                 ----------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:98:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | / macro_rules! bail {
[INFO] [stdout]  91 | |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 | |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]  93 | |     };
[INFO] [stdout] ...   |
[INFO] [stdout]  98 | |         return Err($crate::Error::Msg(format!($fmt, $($arg)*).into()).bt())
[INFO] [stdout]     | |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]  99 | |     };
[INFO] [stdout] 100 | | }
[INFO] [stdout]     | |_- this error originates in the macro `bail` which comes from the expansion of the macro `extract_dims`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/layout.rs:414:1
[INFO] [stdout]     |
[INFO] [stdout] 414 |   extract_dims!(dims0, 0, |_: &[usize]| (), ());
[INFO] [stdout]     |   --------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:98:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | / macro_rules! bail {
[INFO] [stdout]  91 | |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 | |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]  93 | |     };
[INFO] [stdout] ...   |
[INFO] [stdout]  98 | |         return Err($crate::Error::Msg(format!($fmt, $($arg)*).into()).bt())
[INFO] [stdout]     | |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]  99 | |     };
[INFO] [stdout] 100 | | }
[INFO] [stdout]     | |_- this error originates in the macro `bail` which comes from the expansion of the macro `extract_dims`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/layout.rs:415:1
[INFO] [stdout]     |
[INFO] [stdout] 415 |   extract_dims!(dims1, 1, |d: &[usize]| d[0], usize);
[INFO] [stdout]     |   -------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:98:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | / macro_rules! bail {
[INFO] [stdout]  91 | |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 | |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]  93 | |     };
[INFO] [stdout] ...   |
[INFO] [stdout]  98 | |         return Err($crate::Error::Msg(format!($fmt, $($arg)*).into()).bt())
[INFO] [stdout]     | |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]  99 | |     };
[INFO] [stdout] 100 | | }
[INFO] [stdout]     | |_- this error originates in the macro `bail` which comes from the expansion of the macro `extract_dims`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/layout.rs:416:1
[INFO] [stdout]     |
[INFO] [stdout] 416 |   extract_dims!(dims2, 2, |d: &[usize]| (d[0], d[1]), (usize, usize));
[INFO] [stdout]     |   ------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:98:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | / macro_rules! bail {
[INFO] [stdout]  91 | |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 | |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]  93 | |     };
[INFO] [stdout] ...   |
[INFO] [stdout]  98 | |         return Err($crate::Error::Msg(format!($fmt, $($arg)*).into()).bt())
[INFO] [stdout]     | |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]  99 | |     };
[INFO] [stdout] 100 | | }
[INFO] [stdout]     | |_- this error originates in the macro `bail` which comes from the expansion of the macro `extract_dims`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/layout.rs:417:1
[INFO] [stdout]     |
[INFO] [stdout] 417 |   extract_dims!(dims3, 3, |d: &[usize]| (d[0], d[1], d[2]), (usize, usize, usize));
[INFO] [stdout]     |   -------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:98:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | / macro_rules! bail {
[INFO] [stdout]  91 | |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 | |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]  93 | |     };
[INFO] [stdout] ...   |
[INFO] [stdout]  98 | |         return Err($crate::Error::Msg(format!($fmt, $($arg)*).into()).bt())
[INFO] [stdout]     | |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]  99 | |     };
[INFO] [stdout] 100 | | }
[INFO] [stdout]     | |_- this error originates in the macro `bail` which comes from the expansion of the macro `extract_dims`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/layout.rs:418:1
[INFO] [stdout]     |
[INFO] [stdout] 418 |   extract_dims!(dims4, 4, |d: &[usize]| (d[0], d[1], d[2], d[3]), (usize, usize, usize, usize));
[INFO] [stdout]     |   --------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:98:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | / macro_rules! bail {
[INFO] [stdout]  91 | |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 | |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]  93 | |     };
[INFO] [stdout] ...   |
[INFO] [stdout]  98 | |         return Err($crate::Error::Msg(format!($fmt, $($arg)*).into()).bt())
[INFO] [stdout]     | |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]  99 | |     };
[INFO] [stdout] 100 | | }
[INFO] [stdout]     | |_- this error originates in the macro `bail` which comes from the expansion of the macro `extract_dims`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/layout.rs:419:1
[INFO] [stdout]     |
[INFO] [stdout] 419 | / extract_dims!(
[INFO] [stdout] 420 | |     dims5,
[INFO] [stdout] 421 | |     5,
[INFO] [stdout] 422 | |     |d: &[usize]| (d[0], d[1], d[2], d[3], d[4]),
[INFO] [stdout] 423 | |     (usize, usize, usize, usize, usize)
[INFO] [stdout] 424 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/layout.rs:444:9
[INFO] [stdout]     |
[INFO] [stdout] 444 |         bail!("cannot reshape tensor of {el_count} elements to {s:?}")
[INFO] [stdout]     |         -------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/layout.rs:447:9
[INFO] [stdout]     |
[INFO] [stdout] 447 |         bail!("cannot reshape tensor with {el_count} elements to {s:?}")
[INFO] [stdout]     |         ---------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/layout.rs:604:17
[INFO] [stdout]     |
[INFO] [stdout] 604 |                 bail!("cannot collapse dims, {self:?}")
[INFO] [stdout]     |                 --------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lazy_buffer.rs:176:21
[INFO] [stdout]     |
[INFO] [stdout] 176 |             None => bail!("no data"),
[INFO] [stdout]     |                     ---------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:98:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout] ...
[INFO] [stdout]  98 |         return Err($crate::Error::Msg(format!($fmt, $($arg)*).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lazy_buffer.rs:261:13
[INFO] [stdout]     |
[INFO] [stdout] 261 |             bail!("shape mismatch in {op:?}, {:?} vs {:?}", self.shape, rhs.shape)
[INFO] [stdout]     |             ---------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:98:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout] ...
[INFO] [stdout]  98 |         return Err($crate::Error::Msg(format!($fmt, $($arg)*).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lazy_buffer.rs:264:13
[INFO] [stdout]     |
[INFO] [stdout] 264 |             bail!("dtype mismatch in {op:?}, {:?} vs {:?}", self.dtype, rhs.dtype)
[INFO] [stdout]     |             ---------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:98:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout] ...
[INFO] [stdout]  98 |         return Err($crate::Error::Msg(format!($fmt, $($arg)*).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lazy_buffer.rs:334:13
[INFO] [stdout]     |
[INFO] [stdout] 334 |             bail!("shape mismatch in set, {:?} vs {:?}", self.shape, values.shape)
[INFO] [stdout]     |             ---------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:98:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout] ...
[INFO] [stdout]  98 |         return Err($crate::Error::Msg(format!($fmt, $($arg)*).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lazy_buffer.rs:337:13
[INFO] [stdout]     |
[INFO] [stdout] 337 |             bail!("dtype mismatch in set, {:?} vs {:?}", self.dtype, values.dtype)
[INFO] [stdout]     |             ---------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:98:39
[INFO] [stdout]     |
[INFO] [stdout]  90 |   macro_rules! bail {
[INFO] [stdout] ...
[INFO] [stdout]  98 |           return Err($crate::Error::Msg(format!($fmt, $($arg)*).into()).bt())
[INFO] [stdout]     |                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lazy_buffer.rs:361:13
[INFO] [stdout]     |
[INFO] [stdout] 361 | /             bail!(
[INFO] [stdout] 362 | |                 "set_l out of bounds, dst shape {:?}, layout {dst_layout:?}, max off {max_offset}",
[INFO] [stdout] 363 | |                 self.shape()
[INFO] [stdout] 364 | |             )
[INFO] [stdout]     | |_____________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:98:39
[INFO] [stdout]     |
[INFO] [stdout]  90 |   macro_rules! bail {
[INFO] [stdout] ...
[INFO] [stdout]  98 |           return Err($crate::Error::Msg(format!($fmt, $($arg)*).into()).bt())
[INFO] [stdout]     |                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lazy_buffer.rs:367:13
[INFO] [stdout]     |
[INFO] [stdout] 367 | /             bail!(
[INFO] [stdout] 368 | |                 "set_l mismatch between the values shape {:?} and layout {dst_layout:?}",
[INFO] [stdout] 369 | |                 values.shape()
[INFO] [stdout] 370 | |             )
[INFO] [stdout]     | |_____________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:98:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout] ...
[INFO] [stdout]  98 |         return Err($crate::Error::Msg(format!($fmt, $($arg)*).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lazy_buffer.rs:373:13
[INFO] [stdout]     |
[INFO] [stdout] 373 |             bail!("dtype mismatch in set, {:?} vs {:?}", self.dtype, values.dtype)
[INFO] [stdout]     |             ---------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lazy_buffer.rs:421:13
[INFO] [stdout]     |
[INFO] [stdout] 421 |             bail!("shape mismatch in matmul {lhs_dims:?} {rhs_dims:?}")
[INFO] [stdout]     |             ----------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lazy_buffer.rs:435:13
[INFO] [stdout]     |
[INFO] [stdout] 435 |             bail!("shape mismatch in matmul {lhs_dims:?} {rhs_dims:?}")
[INFO] [stdout]     |             ----------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lazy_buffer.rs:479:13
[INFO] [stdout]     |
[INFO] [stdout] 479 |             bail!("unexpected target sizes for split_dim {dim}, {size1}x{size2} != {size}",)
[INFO] [stdout]     |             -------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:98:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout] ...
[INFO] [stdout]  98 |         return Err($crate::Error::Msg(format!($fmt, $($arg)*).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lazy_buffer.rs:500:13
[INFO] [stdout]     |
[INFO] [stdout] 500 |             bail!("unexpected dim for merge_dims {dim} {:?}", self.shape())
[INFO] [stdout]     |             --------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lazy_buffer.rs:523:13
[INFO] [stdout]     |
[INFO] [stdout] 523 |             bail!("cannot squeeze on dim {dim} for shape {dims:?}")
[INFO] [stdout]     |             ------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:98:39
[INFO] [stdout]     |
[INFO] [stdout]  90 |   macro_rules! bail {
[INFO] [stdout] ...
[INFO] [stdout]  98 |           return Err($crate::Error::Msg(format!($fmt, $($arg)*).into()).bt())
[INFO] [stdout]     |                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lazy_buffer.rs:551:13
[INFO] [stdout]     |
[INFO] [stdout] 551 | /             bail!(
[INFO] [stdout] 552 | |                 "cannot reshape between {:?} ({src_nel} elts) and {s:?} ({dst_nel} elts)",
[INFO] [stdout] 553 | |                 self.shape()
[INFO] [stdout] 554 | |             )
[INFO] [stdout]     | |_____________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/const.rs:128:13
[INFO] [stdout]     |
[INFO] [stdout] 128 |             crate::bail!("cannot use nan in const")
[INFO] [stdout]     |             --------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]   --> src/error.rs:92:39
[INFO] [stdout]    |
[INFO] [stdout] 90 | macro_rules! bail {
[INFO] [stdout] 91 |     ($msg:literal $(,)?) => {
[INFO] [stdout] 92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]    |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/cpu_code_gen.rs:72:9
[INFO] [stdout]    |
[INFO] [stdout] 72 |         bail!("TODO: add the reduce code if needed")
[INFO] [stdout]    |         -------------------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/cpu_code_gen.rs:120:21
[INFO] [stdout]     |
[INFO] [stdout] 120 |                     bail!("unmatched EndRange")
[INFO] [stdout]     |                     --------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/cpu_code_gen.rs:162:17
[INFO] [stdout]     |
[INFO] [stdout] 162 |                 bail!("thread-id is currently not supported in the cpu backend")
[INFO] [stdout]     |                 ---------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/cpu_code_gen.rs:166:17
[INFO] [stdout]     |
[INFO] [stdout] 166 |                 bail!("block-id is currently not supported in the cpu backend")
[INFO] [stdout]     |                 --------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/cpu_code_gen.rs:183:9
[INFO] [stdout]     |
[INFO] [stdout] 183 |         bail!("unmatched Range")
[INFO] [stdout]     |         ------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:98:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout] ...
[INFO] [stdout]  98 |         return Err($crate::Error::Msg(format!($fmt, $($arg)*).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/cpu_runtime.rs:331:18
[INFO] [stdout]     |
[INFO] [stdout] 331 |             _ => crate::bail!("unsupported number of args for kernel {}", args.len()),
[INFO] [stdout]     |                  -------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 |   macro_rules! bail {
[INFO] [stdout]  91 |       ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |           return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                         ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/cpu_runtime.rs:352:17
[INFO] [stdout]     |
[INFO] [stdout] 352 | /                 crate::bail!(
[INFO] [stdout] 353 | |                     "incorrect dtypes for matmul, dst: {dst_dt:?}, lhs: {lhs_dt:?}, rhs: {rhs_dt:?}"
[INFO] [stdout] 354 | |                 )
[INFO] [stdout]     | |_________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:98:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout] ...
[INFO] [stdout]  98 |         return Err($crate::Error::Msg(format!($fmt, $($arg)*).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/cpu_runtime.rs:381:13
[INFO] [stdout]     |
[INFO] [stdout] 381 |             crate::bail!("dtoh len mismatch, dst {}, len {}", self.len(), src.len())
[INFO] [stdout]     |             ------------------------------------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:98:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout] ...
[INFO] [stdout]  98 |         return Err($crate::Error::Msg(format!($fmt, $($arg)*).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/cpu_runtime.rs:390:17
[INFO] [stdout]     |
[INFO] [stdout] 390 |                 crate::bail!("htod dtype mismatch, dst {dtype:?}, src {:?}", DT::DTYPE)
[INFO] [stdout]     |                 ----------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:98:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout] ...
[INFO] [stdout]  98 |         return Err($crate::Error::Msg(format!($fmt, $($arg)*).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/cpu_runtime.rs:401:13
[INFO] [stdout]     |
[INFO] [stdout] 401 |             crate::bail!("dtoh len mismatch, dst {}, len {}", dst.len(), self.len())
[INFO] [stdout]     |             ------------------------------------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:98:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout] ...
[INFO] [stdout]  98 |         return Err($crate::Error::Msg(format!($fmt, $($arg)*).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/cpu_runtime.rs:409:23
[INFO] [stdout]     |
[INFO] [stdout] 409 |             (_, _) => crate::bail!("dtoh dtype mismatch, dst {:?}, src {dtype:?}", DT::DTYPE),
[INFO] [stdout]     |                       ----------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:98:39
[INFO] [stdout]     |
[INFO] [stdout]  90 |   macro_rules! bail {
[INFO] [stdout] ...
[INFO] [stdout]  98 |           return Err($crate::Error::Msg(format!($fmt, $($arg)*).into()).bt())
[INFO] [stdout]     |                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/cpu_runtime.rs:491:17
[INFO] [stdout]     |
[INFO] [stdout] 491 | /                 crate::bail!(
[INFO] [stdout] 492 | |                     "compilation failed\nstdout:\n{}\nstderr:{}",
[INFO] [stdout] 493 | |                     String::from_utf8_lossy(&output.stdout),
[INFO] [stdout] 494 | |                     String::from_utf8_lossy(&output.stderr)
[INFO] [stdout] 495 | |                 )
[INFO] [stdout]     | |_________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/cpu_runtime.rs:563:18
[INFO] [stdout]     |
[INFO] [stdout] 563 |             _ => crate::bail!("unsupported dtype for gemm"),
[INFO] [stdout]     |                  ------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:98:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | / macro_rules! bail {
[INFO] [stdout]  91 | |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 | |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]  93 | |     };
[INFO] [stdout] ...   |
[INFO] [stdout]  98 | |         return Err($crate::Error::Msg(format!($fmt, $($arg)*).into()).bt())
[INFO] [stdout]     | |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]  99 | |     };
[INFO] [stdout] 100 | | }
[INFO] [stdout]     | |_- this error originates in the macro `bail` which comes from the expansion of the macro `with_dtype`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/dtype.rs:125:1
[INFO] [stdout]     |
[INFO] [stdout] 125 |   with_dtype!(bf16, BF16);
[INFO] [stdout]     |   ----------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:98:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | / macro_rules! bail {
[INFO] [stdout]  91 | |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 | |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]  93 | |     };
[INFO] [stdout] ...   |
[INFO] [stdout]  98 | |         return Err($crate::Error::Msg(format!($fmt, $($arg)*).into()).bt())
[INFO] [stdout]     | |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]  99 | |     };
[INFO] [stdout] 100 | | }
[INFO] [stdout]     | |_- this error originates in the macro `bail` which comes from the expansion of the macro `with_dtype`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/dtype.rs:125:1
[INFO] [stdout]     |
[INFO] [stdout] 125 |   with_dtype!(bf16, BF16);
[INFO] [stdout]     |   ----------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:98:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | / macro_rules! bail {
[INFO] [stdout]  91 | |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 | |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]  93 | |     };
[INFO] [stdout] ...   |
[INFO] [stdout]  98 | |         return Err($crate::Error::Msg(format!($fmt, $($arg)*).into()).bt())
[INFO] [stdout]     | |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]  99 | |     };
[INFO] [stdout] 100 | | }
[INFO] [stdout]     | |_- this error originates in the macro `bail` which comes from the expansion of the macro `with_dtype`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/dtype.rs:126:1
[INFO] [stdout]     |
[INFO] [stdout] 126 |   with_dtype!(f16, F16);
[INFO] [stdout]     |   --------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:98:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | / macro_rules! bail {
[INFO] [stdout]  91 | |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 | |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]  93 | |     };
[INFO] [stdout] ...   |
[INFO] [stdout]  98 | |         return Err($crate::Error::Msg(format!($fmt, $($arg)*).into()).bt())
[INFO] [stdout]     | |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]  99 | |     };
[INFO] [stdout] 100 | | }
[INFO] [stdout]     | |_- this error originates in the macro `bail` which comes from the expansion of the macro `with_dtype`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/dtype.rs:126:1
[INFO] [stdout]     |
[INFO] [stdout] 126 |   with_dtype!(f16, F16);
[INFO] [stdout]     |   --------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:98:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | / macro_rules! bail {
[INFO] [stdout]  91 | |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 | |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]  93 | |     };
[INFO] [stdout] ...   |
[INFO] [stdout]  98 | |         return Err($crate::Error::Msg(format!($fmt, $($arg)*).into()).bt())
[INFO] [stdout]     | |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]  99 | |     };
[INFO] [stdout] 100 | | }
[INFO] [stdout]     | |_- this error originates in the macro `bail` which comes from the expansion of the macro `with_dtype`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/dtype.rs:127:1
[INFO] [stdout]     |
[INFO] [stdout] 127 |   with_dtype!(f32, F32);
[INFO] [stdout]     |   --------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:98:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | / macro_rules! bail {
[INFO] [stdout]  91 | |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 | |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]  93 | |     };
[INFO] [stdout] ...   |
[INFO] [stdout]  98 | |         return Err($crate::Error::Msg(format!($fmt, $($arg)*).into()).bt())
[INFO] [stdout]     | |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]  99 | |     };
[INFO] [stdout] 100 | | }
[INFO] [stdout]     | |_- this error originates in the macro `bail` which comes from the expansion of the macro `with_dtype`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/dtype.rs:127:1
[INFO] [stdout]     |
[INFO] [stdout] 127 |   with_dtype!(f32, F32);
[INFO] [stdout]     |   --------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:98:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | / macro_rules! bail {
[INFO] [stdout]  91 | |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 | |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]  93 | |     };
[INFO] [stdout] ...   |
[INFO] [stdout]  98 | |         return Err($crate::Error::Msg(format!($fmt, $($arg)*).into()).bt())
[INFO] [stdout]     | |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]  99 | |     };
[INFO] [stdout] 100 | | }
[INFO] [stdout]     | |_- this error originates in the macro `bail` which comes from the expansion of the macro `with_dtype`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/dtype.rs:128:1
[INFO] [stdout]     |
[INFO] [stdout] 128 |   with_dtype!(i32, I32);
[INFO] [stdout]     |   --------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:98:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | / macro_rules! bail {
[INFO] [stdout]  91 | |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 | |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]  93 | |     };
[INFO] [stdout] ...   |
[INFO] [stdout]  98 | |         return Err($crate::Error::Msg(format!($fmt, $($arg)*).into()).bt())
[INFO] [stdout]     | |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]  99 | |     };
[INFO] [stdout] 100 | | }
[INFO] [stdout]     | |_- this error originates in the macro `bail` which comes from the expansion of the macro `with_dtype`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/dtype.rs:128:1
[INFO] [stdout]     |
[INFO] [stdout] 128 |   with_dtype!(i32, I32);
[INFO] [stdout]     |   --------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:98:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | / macro_rules! bail {
[INFO] [stdout]  91 | |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 | |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]  93 | |     };
[INFO] [stdout] ...   |
[INFO] [stdout]  98 | |         return Err($crate::Error::Msg(format!($fmt, $($arg)*).into()).bt())
[INFO] [stdout]     | |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]  99 | |     };
[INFO] [stdout] 100 | | }
[INFO] [stdout]     | |_- this error originates in the macro `bail` which comes from the expansion of the macro `with_dtype`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/dtype.rs:129:1
[INFO] [stdout]     |
[INFO] [stdout] 129 |   with_dtype!(i64, I64);
[INFO] [stdout]     |   --------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:98:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | / macro_rules! bail {
[INFO] [stdout]  91 | |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 | |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]  93 | |     };
[INFO] [stdout] ...   |
[INFO] [stdout]  98 | |         return Err($crate::Error::Msg(format!($fmt, $($arg)*).into()).bt())
[INFO] [stdout]     | |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]  99 | |     };
[INFO] [stdout] 100 | | }
[INFO] [stdout]     | |_- this error originates in the macro `bail` which comes from the expansion of the macro `with_dtype`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/dtype.rs:129:1
[INFO] [stdout]     |
[INFO] [stdout] 129 |   with_dtype!(i64, I64);
[INFO] [stdout]     |   --------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:125:18
[INFO] [stdout]     |
[INFO] [stdout] 125 |             _ => crate::bail!("unexpected buffer type"),
[INFO] [stdout]     |                  -------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:132:18
[INFO] [stdout]     |
[INFO] [stdout] 132 |             _ => crate::bail!("unexpected buffer type"),
[INFO] [stdout]     |                  -------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lazy_buffer.rs:572:13
[INFO] [stdout]     |
[INFO] [stdout] 572 |             bail!("cannot narrow, offset {offset} + length {length} > size {dim}")
[INFO] [stdout]     |             ---------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:98:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout] ...
[INFO] [stdout]  98 |         return Err($crate::Error::Msg(format!($fmt, $($arg)*).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lazy_buffer.rs:594:13
[INFO] [stdout]     |
[INFO] [stdout] 594 |             bail!("target shape {s:?} has less dimensions than original shape {:?}", self.shape())
[INFO] [stdout]     |             -------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:98:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout] ...
[INFO] [stdout]  98 |         return Err($crate::Error::Msg(format!($fmt, $($arg)*).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lazy_buffer.rs:604:21
[INFO] [stdout]     |
[INFO] [stdout] 604 |                     bail!("cannot broadcast from {:?} to {s:?}", self.shape)
[INFO] [stdout]     |                     -------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lazy_buffer.rs:649:23
[INFO] [stdout]     |
[INFO] [stdout] 649 |             Err(_) => bail!("unable to create const for {c:?}"),
[INFO] [stdout]     |                       ----------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:98:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout] ...
[INFO] [stdout]  98 |         return Err($crate::Error::Msg(format!($fmt, $($arg)*).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lazy_buffer.rs:672:13
[INFO] [stdout]     |
[INFO] [stdout] 672 |             bail!("unexpected number of elements {} for shape {s:?}", data.len())
[INFO] [stdout]     |             --------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:98:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout] ...
[INFO] [stdout]  98 |         return Err($crate::Error::Msg(format!($fmt, $($arg)*).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lazy_buffer.rs:698:13
[INFO] [stdout]     |
[INFO] [stdout] 698 |             bail!("unexpected number of elements {} for shape {s:?}", data.len())
[INFO] [stdout]     |             --------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lazy_buffer.rs:724:13
[INFO] [stdout]     |
[INFO] [stdout] 724 |             bail!("empty list in cat")
[INFO] [stdout]     |             -------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lazy_buffer.rs:736:17
[INFO] [stdout]     |
[INFO] [stdout] 736 |                 bail!("mismatch between dtypes in cat, shapes: {shapes:?}")
[INFO] [stdout]     |                 ----------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lazy_buffer.rs:740:17
[INFO] [stdout]     |
[INFO] [stdout] 740 |                 bail!("mismatch between ranks in cat, shapes: {shapes:?}")
[INFO] [stdout]     |                 ---------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:98:39
[INFO] [stdout]     |
[INFO] [stdout]  90 |   macro_rules! bail {
[INFO] [stdout] ...
[INFO] [stdout]  98 |           return Err($crate::Error::Msg(format!($fmt, $($arg)*).into()).bt())
[INFO] [stdout]     |                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lazy_buffer.rs:745:21
[INFO] [stdout]     |
[INFO] [stdout] 745 | /                     bail!(
[INFO] [stdout] 746 | |                         "mismatch between shapes in cat on dim {dim}, arg0: {:?}, arg{arg_idx}: {:?}",
[INFO] [stdout] 747 | |                         arg0.shape(),
[INFO] [stdout] 748 | |                         arg.shape()
[INFO] [stdout] 749 | |                     )
[INFO] [stdout]     | |_____________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]   --> src/error.rs:92:39
[INFO] [stdout]    |
[INFO] [stdout] 90 | macro_rules! bail {
[INFO] [stdout] 91 |     ($msg:literal $(,)?) => {
[INFO] [stdout] 92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]    |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/lower.rs:24:31
[INFO] [stdout]    |
[INFO] [stdout] 24 |             E::Range(_, _) => crate::bail!("TODO range is not supported yet"),
[INFO] [stdout]    |                               ----------------------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]   --> src/error.rs:98:39
[INFO] [stdout]    |
[INFO] [stdout] 90 | macro_rules! bail {
[INFO] [stdout] ...
[INFO] [stdout] 98 |         return Err($crate::Error::Msg(format!($fmt, $($arg)*).into()).bt())
[INFO] [stdout]    |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/lower.rs:52:21
[INFO] [stdout]    |
[INFO] [stdout] 52 |             None => crate::bail!("unknown arg {:?}", self.ptr().id()),
[INFO] [stdout]    |                     ------------------------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lower.rs:150:40
[INFO] [stdout]     |
[INFO] [stdout] 150 |                 ssa::Type::Value(_) => crate::bail!("non-pointer arguments are not supported yet"),
[INFO] [stdout]     |                                        ----------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:98:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout] ...
[INFO] [stdout]  98 |         return Err($crate::Error::Msg(format!($fmt, $($arg)*).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lower_op.rs:139:25
[INFO] [stdout]     |
[INFO] [stdout] 139 |                         bail!("unexpected dim for broadcast, {dim} {:?}", shape)
[INFO] [stdout]     |                         -------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:98:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout] ...
[INFO] [stdout]  98 |         return Err($crate::Error::Msg(format!($fmt, $($arg)*).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lower_op.rs:149:21
[INFO] [stdout]     |
[INFO] [stdout] 149 |                     bail!("unexpected dim for narrow, {dim} {:?}", shape)
[INFO] [stdout]     |                     ----------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:98:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout] ...
[INFO] [stdout]  98 |         return Err($crate::Error::Msg(format!($fmt, $($arg)*).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lower_op.rs:155:21
[INFO] [stdout]     |
[INFO] [stdout] 155 |                     bail!("unexpected dims for transpose {dim1} {dim2}, {:?}", shape)
[INFO] [stdout]     |                     ----------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lower_op.rs:161:21
[INFO] [stdout]     |
[INFO] [stdout] 161 |                     bail!("unexpected split dim {dim} src {shape:?}")
[INFO] [stdout]     |                     ------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lower_op.rs:164:21
[INFO] [stdout]     |
[INFO] [stdout] 164 |                     bail!("unexpected split dims {lhs}x{rhs} dst {shape:?}")
[INFO] [stdout]     |                     -------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lower_op.rs:180:21
[INFO] [stdout]     |
[INFO] [stdout] 180 |                     bail!("unexpected merge dim {dim} dst {shape:?}")
[INFO] [stdout]     |                     ------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lower_op.rs:183:21
[INFO] [stdout]     |
[INFO] [stdout] 183 |                     bail!("unexpected merge dims {lhs}x{rhs} src {arg_shape:?}")
[INFO] [stdout]     |                     ------------------------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lower_op.rs:209:13
[INFO] [stdout]     |
[INFO] [stdout] 209 |             bail!("len mismatch between strides {self:?} and idxs {idxs:?}")
[INFO] [stdout]     |             ---------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lower_op.rs:317:29
[INFO] [stdout]     |
[INFO] [stdout] 317 |                     None => bail!("unknown arg {src:?}"),
[INFO] [stdout]     |                             ---------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:98:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout] ...
[INFO] [stdout]  98 |         return Err($crate::Error::Msg(format!($fmt, $($arg)*).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lower_op.rs:372:29
[INFO] [stdout]     |
[INFO] [stdout] 372 | ...                   bail!("unexpected dim for reduce, {dim} {:?}", self.shape)
[INFO] [stdout]     |                       ---------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lower_op.rs:415:40
[INFO] [stdout]     |
[INFO] [stdout] 415 |                 ssa::Type::Value(_) => bail!("non-pointer arguments are not supported yet"),
[INFO] [stdout]     |                                        ---------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lower_op.rs:431:25
[INFO] [stdout]     |
[INFO] [stdout] 431 |                 None => bail!("unknown arg {dst:?}"),
[INFO] [stdout]     |                         ---------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lower_op.rs:507:37
[INFO] [stdout]     |
[INFO] [stdout] 507 |                 A::Reduce { .. } => bail!("unexpected result in optimize step"),
[INFO] [stdout]     |                                     ------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lower_op.rs:515:29
[INFO] [stdout]     |
[INFO] [stdout] 515 | ...                   bail!("unexpected layout op {op:?}")
[INFO] [stdout]     |                       ------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]   --> src/error.rs:92:39
[INFO] [stdout]    |
[INFO] [stdout] 90 | macro_rules! bail {
[INFO] [stdout] 91 |     ($msg:literal $(,)?) => {
[INFO] [stdout] 92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]    |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/safetensors.rs:92:22
[INFO] [stdout]    |
[INFO] [stdout] 92 |             dtype => crate::bail!("unsupported dtype for {name}: {dtype:?}"),
[INFO] [stdout]    |                      ------------------------------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/safetensors.rs:134:22
[INFO] [stdout]     |
[INFO] [stdout] 134 |             dtype => crate::bail!("unsupported dtype for {name}: {dtype:?}"),
[INFO] [stdout]     |                      ------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]   --> src/error.rs:92:39
[INFO] [stdout]    |
[INFO] [stdout] 90 | macro_rules! bail {
[INFO] [stdout] 91 |     ($msg:literal $(,)?) => {
[INFO] [stdout] 92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]    |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/samples.rs:75:13
[INFO] [stdout]    |
[INFO] [stdout] 75 |             crate::bail!("last-dim {dim2} must be divisible by block size {block_size}")
[INFO] [stdout]    |             ---------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/samples.rs:187:13
[INFO] [stdout]     |
[INFO] [stdout] 187 |             crate::bail!("last-dim {dim2} must be divisible by block size {block_size}")
[INFO] [stdout]     |             ---------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]   --> src/error.rs:92:39
[INFO] [stdout]    |
[INFO] [stdout] 90 | macro_rules! bail {
[INFO] [stdout] 91 |     ($msg:literal $(,)?) => {
[INFO] [stdout] 92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]    |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/schedule.rs:74:21
[INFO] [stdout]    |
[INFO] [stdout] 74 |             None => crate::bail!("no arg for id {arg_id:?}"),
[INFO] [stdout]    |                     ---------------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]   --> src/error.rs:92:39
[INFO] [stdout]    |
[INFO] [stdout] 90 | macro_rules! bail {
[INFO] [stdout] 91 |     ($msg:literal $(,)?) => {
[INFO] [stdout] 92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]    |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/schedule.rs:80:13
[INFO] [stdout]    |
[INFO] [stdout] 80 |             crate::bail!("no buffers provided")
[INFO] [stdout]    |             ----------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/schedule.rs:323:21
[INFO] [stdout]     |
[INFO] [stdout] 323 |             None => crate::bail!("no arg for id {arg_id:?}"),
[INFO] [stdout]     |                     ---------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:146:13
[INFO] [stdout]     |
[INFO] [stdout] 146 |             crate::bail!("not an i32 {self:?}")
[INFO] [stdout]     |             ----------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:154:13
[INFO] [stdout]     |
[INFO] [stdout] 154 |             crate::bail!("not a f32 {self:?}")
[INFO] [stdout]     |             ---------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:174:21
[INFO] [stdout]     |
[INFO] [stdout] 174 |             None => crate::bail!("set out of bound {id}"),
[INFO] [stdout]     |                     ------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:183:21
[INFO] [stdout]     |
[INFO] [stdout] 183 |             None => crate::bail!("get out of bound {id:?}"),
[INFO] [stdout]     |                     --------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:233:21
[INFO] [stdout]     |
[INFO] [stdout] 233 |                     crate::bail!("diverging threads in warp")
[INFO] [stdout]     |                     ----------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:244:21
[INFO] [stdout]     |
[INFO] [stdout] 244 |                     crate::bail!("get out of bounds {current_idx}")
[INFO] [stdout]     |                     ----------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:262:25
[INFO] [stdout]     |
[INFO] [stdout] 262 |                         crate::bail!("diverging threads in warp")
[INFO] [stdout]     |                         ----------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:286:26
[INFO] [stdout]     |
[INFO] [stdout] 286 |                     _ => crate::bail!("unexpected dtype for src in load {src:?}"),
[INFO] [stdout]     |                          -------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:306:26
[INFO] [stdout]     |
[INFO] [stdout] 306 |                     _ => crate::bail!("unexpected dtype for src in store {dst:?}"),
[INFO] [stdout]     |                          --------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:315:34
[INFO] [stdout]     |
[INFO] [stdout] 315 |                     (None, v) => crate::bail!("no buffer for store {v:?}"),
[INFO] [stdout]     |                                  ----------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:316:31
[INFO] [stdout]     |
[INFO] [stdout] 316 |                     (_, v) => crate::bail!("unexpected dtype for value in store {v:?}"),
[INFO] [stdout]     |                               --------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:327:39
[INFO] [stdout]     |
[INFO] [stdout] 327 |                     (B::Add, _, _) => crate::bail!("dtype mismatch for {op:?}"),
[INFO] [stdout]     |                                       ----------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:330:39
[INFO] [stdout]     |
[INFO] [stdout] 330 |                     (B::Mul, _, _) => crate::bail!("dtype mismatch for {op:?}"),
[INFO] [stdout]     |                                       ----------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:333:39
[INFO] [stdout]     |
[INFO] [stdout] 333 |                     (B::Sub, _, _) => crate::bail!("dtype mismatch for {op:?}"),
[INFO] [stdout]     |                                       ----------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:336:39
[INFO] [stdout]     |
[INFO] [stdout] 336 |                     (B::Div, _, _) => crate::bail!("dtype mismatch for {op:?}"),
[INFO] [stdout]     |                                       ----------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:339:39
[INFO] [stdout]     |
[INFO] [stdout] 339 |                     (B::Mod, _, _) => crate::bail!("dtype mismatch for {op:?}"),
[INFO] [stdout]     |                                       ----------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:342:39
[INFO] [stdout]     |
[INFO] [stdout] 342 |                     (B::Max, _, _) => crate::bail!("dtype mismatch for {op:?}"),
[INFO] [stdout]     |                                       ----------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:345:39
[INFO] [stdout]     |
[INFO] [stdout] 345 |                     (B::Min, _, _) => crate::bail!("dtype mismatch for {op:?}"),
[INFO] [stdout]     |                                       ----------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:356:36
[INFO] [stdout]     |
[INFO] [stdout] 356 |                     (U::Neg, _) => crate::bail!("dtype mismatch for {op:?} {arg:?}"),
[INFO] [stdout]     |                                    ------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:358:36
[INFO] [stdout]     |
[INFO] [stdout] 358 |                     (U::Exp, _) => crate::bail!("dtype mismatch for {op:?} {arg:?}"),
[INFO] [stdout]     |                                    ------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:360:37
[INFO] [stdout]     |
[INFO] [stdout] 360 |                     (U::Sqrt, _) => crate::bail!("dtype mismatch for {op:?} {arg:?}"),
[INFO] [stdout]     |                                     ------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:362:36
[INFO] [stdout]     |
[INFO] [stdout] 362 |                     (U::Sin, _) => crate::bail!("dtype mismatch for {op:?} {arg:?}"),
[INFO] [stdout]     |                                    ------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:364:36
[INFO] [stdout]     |
[INFO] [stdout] 364 |                     (U::Cos, _) => crate::bail!("dtype mismatch for {op:?} {arg:?}"),
[INFO] [stdout]     |                                    ------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:368:30
[INFO] [stdout]     |
[INFO] [stdout] 368 |                         _ => crate::bail!("dtype mismatch for {op:?} {arg:?} {dtype:?}"),
[INFO] [stdout]     |                              ----------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:373:30
[INFO] [stdout]     |
[INFO] [stdout] 373 |                         _ => crate::bail!("dtype mismatch for {op:?} {arg:?} {dtype:?}"),
[INFO] [stdout]     |                              ----------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:375:40
[INFO] [stdout]     |
[INFO] [stdout] 375 |                     (U::Cast(_), _) => crate::bail!("dtype mismatch for {op:?} {arg:?}"),
[INFO] [stdout]     |                                        ------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/interpreter.rs:410:31
[INFO] [stdout]     |
[INFO] [stdout] 410 |                     (_, _) => crate::bail!("dtype mismatch for {op:?} {arg:?}"),
[INFO] [stdout]     |                               ------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lang.rs:308:36
[INFO] [stdout]     |
[INFO] [stdout] 308 |             ssa::Type::Value(_) => crate::bail!("non-pointer arguments are not supported yet"),
[INFO] [stdout]     |                                    ----------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:98:39
[INFO] [stdout]     |
[INFO] [stdout]  90 |   macro_rules! bail {
[INFO] [stdout] ...
[INFO] [stdout]  98 |           return Err($crate::Error::Msg(format!($fmt, $($arg)*).into()).bt())
[INFO] [stdout]     |                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lang.rs:456:13
[INFO] [stdout]     |
[INFO] [stdout] 456 | /             crate::bail!(
[INFO] [stdout] 457 | |                 "target shape {:?} has less dimensions than original shape {:?}",
[INFO] [stdout] 458 | |                 shape,
[INFO] [stdout] 459 | |                 arg.shape
[INFO] [stdout] 460 | |             )
[INFO] [stdout]     | |_____________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:98:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout] ...
[INFO] [stdout]  98 |         return Err($crate::Error::Msg(format!($fmt, $($arg)*).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lang.rs:470:21
[INFO] [stdout]     |
[INFO] [stdout] 470 |                     crate::bail!("cannot broadcast from {:?} to {shape:?}", arg.shape)
[INFO] [stdout]     |                     ------------------------------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lang.rs:500:13
[INFO] [stdout]     |
[INFO] [stdout] 500 |             crate::bail!("no dim {dim} in shape {shape:?}")
[INFO] [stdout]     |             ----------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:98:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout] ...
[INFO] [stdout]  98 |         return Err($crate::Error::Msg(format!($fmt, $($arg)*).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lang.rs:509:13
[INFO] [stdout]     |
[INFO] [stdout] 509 |             crate::bail!("dtype mismatch in {op:?}, lhs: {:?}, rhs: {:?}", lhs.dtype, rhs.dtype)
[INFO] [stdout]     |             ------------------------------------------------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:98:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout] ...
[INFO] [stdout]  98 |         return Err($crate::Error::Msg(format!($fmt, $($arg)*).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lang.rs:515:13
[INFO] [stdout]     |
[INFO] [stdout] 515 |             crate::bail!("shape mismatch in {op:?}, lhs: {:?}, rhs: {:?}", lhs.shape, rhs.shape)
[INFO] [stdout]     |             ------------------------------------------------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lang.rs:531:23
[INFO] [stdout]     |
[INFO] [stdout] 531 |             Err(_) => crate::bail!("unable to create const for {v:?}"),
[INFO] [stdout]     |                       ------------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lang.rs:744:25
[INFO] [stdout]     |
[INFO] [stdout] 744 |                         crate::bail!("unexpected order for arguments in kernel {instrs:?}")
[INFO] [stdout]     |                         ------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lang.rs:772:33
[INFO] [stdout]     |
[INFO] [stdout] 772 | ...                   crate::bail!("range lo is not a const i32/i64")
[INFO] [stdout]     |                       ----------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lang.rs:777:38
[INFO] [stdout]     |
[INFO] [stdout] 777 | ...                   _ => crate::bail!("range lo is not a const"),
[INFO] [stdout]     |                            --------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lang.rs:784:33
[INFO] [stdout]     |
[INFO] [stdout] 784 | ...                   crate::bail!("range up is not a const i32/i64")
[INFO] [stdout]     |                       ----------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lang.rs:789:38
[INFO] [stdout]     |
[INFO] [stdout] 789 | ...                   _ => crate::bail!("range lo is not a const"),
[INFO] [stdout]     |                            --------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lang.rs:795:33
[INFO] [stdout]     |
[INFO] [stdout] 795 |                         None => crate::bail!("unexpected EndRange"),
[INFO] [stdout]     |                                 ----------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/layout.rs:219:17
[INFO] [stdout]     |
[INFO] [stdout] 219 |                 bail!("shape mismatch in binary op '{op}', lhs: {lhs:?} rhs: {rhs:?}")
[INFO] [stdout]     |                 ---------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/layout.rs:235:13
[INFO] [stdout]     |
[INFO] [stdout] 235 |             bail!("dim out of range in '{op}', dim: {dim}, shape: {shape:?}")
[INFO] [stdout]     |             ----------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/layout.rs:243:13
[INFO] [stdout]     |
[INFO] [stdout] 243 |             bail!("dim out of range in '{op}', dim: {dim}, shape: {shape:?}")
[INFO] [stdout]     |             ----------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/layout.rs:316:17
[INFO] [stdout]     |
[INFO] [stdout] 316 |                 bail!("duplicate dim indexes in '{op}', dims: {dims:?}, shape: {shape:?}")
[INFO] [stdout]     |                 -------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/layout.rs:319:17
[INFO] [stdout]     |
[INFO] [stdout] 319 |                 bail!("dim out of range in '{op}', dim: {dim}, shape: {shape:?}")
[INFO] [stdout]     |                 ----------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:98:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | / macro_rules! bail {
[INFO] [stdout]  91 | |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 | |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]  93 | |     };
[INFO] [stdout] ...   |
[INFO] [stdout]  98 | |         return Err($crate::Error::Msg(format!($fmt, $($arg)*).into()).bt())
[INFO] [stdout]     | |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]  99 | |     };
[INFO] [stdout] 100 | | }
[INFO] [stdout]     | |_- this error originates in the macro `bail` which comes from the expansion of the macro `extract_dims`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/layout.rs:414:1
[INFO] [stdout]     |
[INFO] [stdout] 414 |   extract_dims!(dims0, 0, |_: &[usize]| (), ());
[INFO] [stdout]     |   --------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:98:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | / macro_rules! bail {
[INFO] [stdout]  91 | |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 | |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]  93 | |     };
[INFO] [stdout] ...   |
[INFO] [stdout]  98 | |         return Err($crate::Error::Msg(format!($fmt, $($arg)*).into()).bt())
[INFO] [stdout]     | |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]  99 | |     };
[INFO] [stdout] 100 | | }
[INFO] [stdout]     | |_- this error originates in the macro `bail` which comes from the expansion of the macro `extract_dims`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/layout.rs:415:1
[INFO] [stdout]     |
[INFO] [stdout] 415 |   extract_dims!(dims1, 1, |d: &[usize]| d[0], usize);
[INFO] [stdout]     |   -------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:98:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | / macro_rules! bail {
[INFO] [stdout]  91 | |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 | |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]  93 | |     };
[INFO] [stdout] ...   |
[INFO] [stdout]  98 | |         return Err($crate::Error::Msg(format!($fmt, $($arg)*).into()).bt())
[INFO] [stdout]     | |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]  99 | |     };
[INFO] [stdout] 100 | | }
[INFO] [stdout]     | |_- this error originates in the macro `bail` which comes from the expansion of the macro `extract_dims`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/layout.rs:416:1
[INFO] [stdout]     |
[INFO] [stdout] 416 |   extract_dims!(dims2, 2, |d: &[usize]| (d[0], d[1]), (usize, usize));
[INFO] [stdout]     |   ------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:98:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | / macro_rules! bail {
[INFO] [stdout]  91 | |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 | |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]  93 | |     };
[INFO] [stdout] ...   |
[INFO] [stdout]  98 | |         return Err($crate::Error::Msg(format!($fmt, $($arg)*).into()).bt())
[INFO] [stdout]     | |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]  99 | |     };
[INFO] [stdout] 100 | | }
[INFO] [stdout]     | |_- this error originates in the macro `bail` which comes from the expansion of the macro `extract_dims`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/layout.rs:417:1
[INFO] [stdout]     |
[INFO] [stdout] 417 |   extract_dims!(dims3, 3, |d: &[usize]| (d[0], d[1], d[2]), (usize, usize, usize));
[INFO] [stdout]     |   -------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:98:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | / macro_rules! bail {
[INFO] [stdout]  91 | |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 | |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]  93 | |     };
[INFO] [stdout] ...   |
[INFO] [stdout]  98 | |         return Err($crate::Error::Msg(format!($fmt, $($arg)*).into()).bt())
[INFO] [stdout]     | |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]  99 | |     };
[INFO] [stdout] 100 | | }
[INFO] [stdout]     | |_- this error originates in the macro `bail` which comes from the expansion of the macro `extract_dims`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/layout.rs:418:1
[INFO] [stdout]     |
[INFO] [stdout] 418 |   extract_dims!(dims4, 4, |d: &[usize]| (d[0], d[1], d[2], d[3]), (usize, usize, usize, usize));
[INFO] [stdout]     |   --------------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:98:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | / macro_rules! bail {
[INFO] [stdout]  91 | |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 | |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]  93 | |     };
[INFO] [stdout] ...   |
[INFO] [stdout]  98 | |         return Err($crate::Error::Msg(format!($fmt, $($arg)*).into()).bt())
[INFO] [stdout]     | |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]  99 | |     };
[INFO] [stdout] 100 | | }
[INFO] [stdout]     | |_- this error originates in the macro `bail` which comes from the expansion of the macro `extract_dims`
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/layout.rs:419:1
[INFO] [stdout]     |
[INFO] [stdout] 419 | / extract_dims!(
[INFO] [stdout] 420 | |     dims5,
[INFO] [stdout] 421 | |     5,
[INFO] [stdout] 422 | |     |d: &[usize]| (d[0], d[1], d[2], d[3], d[4]),
[INFO] [stdout] 423 | |     (usize, usize, usize, usize, usize)
[INFO] [stdout] 424 | | );
[INFO] [stdout]     | |_- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/layout.rs:444:9
[INFO] [stdout]     |
[INFO] [stdout] 444 |         bail!("cannot reshape tensor of {el_count} elements to {s:?}")
[INFO] [stdout]     |         -------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/layout.rs:447:9
[INFO] [stdout]     |
[INFO] [stdout] 447 |         bail!("cannot reshape tensor with {el_count} elements to {s:?}")
[INFO] [stdout]     |         ---------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/layout.rs:604:17
[INFO] [stdout]     |
[INFO] [stdout] 604 |                 bail!("cannot collapse dims, {self:?}")
[INFO] [stdout]     |                 --------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lazy_buffer.rs:176:21
[INFO] [stdout]     |
[INFO] [stdout] 176 |             None => bail!("no data"),
[INFO] [stdout]     |                     ---------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:98:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout] ...
[INFO] [stdout]  98 |         return Err($crate::Error::Msg(format!($fmt, $($arg)*).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lazy_buffer.rs:261:13
[INFO] [stdout]     |
[INFO] [stdout] 261 |             bail!("shape mismatch in {op:?}, {:?} vs {:?}", self.shape, rhs.shape)
[INFO] [stdout]     |             ---------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:98:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout] ...
[INFO] [stdout]  98 |         return Err($crate::Error::Msg(format!($fmt, $($arg)*).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lazy_buffer.rs:264:13
[INFO] [stdout]     |
[INFO] [stdout] 264 |             bail!("dtype mismatch in {op:?}, {:?} vs {:?}", self.dtype, rhs.dtype)
[INFO] [stdout]     |             ---------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:98:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout] ...
[INFO] [stdout]  98 |         return Err($crate::Error::Msg(format!($fmt, $($arg)*).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lazy_buffer.rs:334:13
[INFO] [stdout]     |
[INFO] [stdout] 334 |             bail!("shape mismatch in set, {:?} vs {:?}", self.shape, values.shape)
[INFO] [stdout]     |             ---------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:98:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout] ...
[INFO] [stdout]  98 |         return Err($crate::Error::Msg(format!($fmt, $($arg)*).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lazy_buffer.rs:337:13
[INFO] [stdout]     |
[INFO] [stdout] 337 |             bail!("dtype mismatch in set, {:?} vs {:?}", self.dtype, values.dtype)
[INFO] [stdout]     |             ---------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:98:39
[INFO] [stdout]     |
[INFO] [stdout]  90 |   macro_rules! bail {
[INFO] [stdout] ...
[INFO] [stdout]  98 |           return Err($crate::Error::Msg(format!($fmt, $($arg)*).into()).bt())
[INFO] [stdout]     |                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lazy_buffer.rs:361:13
[INFO] [stdout]     |
[INFO] [stdout] 361 | /             bail!(
[INFO] [stdout] 362 | |                 "set_l out of bounds, dst shape {:?}, layout {dst_layout:?}, max off {max_offset}",
[INFO] [stdout] 363 | |                 self.shape()
[INFO] [stdout] 364 | |             )
[INFO] [stdout]     | |_____________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:98:39
[INFO] [stdout]     |
[INFO] [stdout]  90 |   macro_rules! bail {
[INFO] [stdout] ...
[INFO] [stdout]  98 |           return Err($crate::Error::Msg(format!($fmt, $($arg)*).into()).bt())
[INFO] [stdout]     |                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lazy_buffer.rs:367:13
[INFO] [stdout]     |
[INFO] [stdout] 367 | /             bail!(
[INFO] [stdout] 368 | |                 "set_l mismatch between the values shape {:?} and layout {dst_layout:?}",
[INFO] [stdout] 369 | |                 values.shape()
[INFO] [stdout] 370 | |             )
[INFO] [stdout]     | |_____________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:98:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout] ...
[INFO] [stdout]  98 |         return Err($crate::Error::Msg(format!($fmt, $($arg)*).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lazy_buffer.rs:373:13
[INFO] [stdout]     |
[INFO] [stdout] 373 |             bail!("dtype mismatch in set, {:?} vs {:?}", self.dtype, values.dtype)
[INFO] [stdout]     |             ---------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `ug` (lib test) due to 134 previous errors
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lazy_buffer.rs:421:13
[INFO] [stdout]     |
[INFO] [stdout] 421 |             bail!("shape mismatch in matmul {lhs_dims:?} {rhs_dims:?}")
[INFO] [stdout]     |             ----------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr] warning: build failed, waiting for other jobs to finish...
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lazy_buffer.rs:435:13
[INFO] [stdout]     |
[INFO] [stdout] 435 |             bail!("shape mismatch in matmul {lhs_dims:?} {rhs_dims:?}")
[INFO] [stdout]     |             ----------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `ug` (lib) due to 134 previous errors
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lazy_buffer.rs:479:13
[INFO] [stdout]     |
[INFO] [stdout] 479 |             bail!("unexpected target sizes for split_dim {dim}, {size1}x{size2} != {size}",)
[INFO] [stdout]     |             -------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:98:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout] ...
[INFO] [stdout]  98 |         return Err($crate::Error::Msg(format!($fmt, $($arg)*).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lazy_buffer.rs:500:13
[INFO] [stdout]     |
[INFO] [stdout] 500 |             bail!("unexpected dim for merge_dims {dim} {:?}", self.shape())
[INFO] [stdout]     |             --------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lazy_buffer.rs:523:13
[INFO] [stdout]     |
[INFO] [stdout] 523 |             bail!("cannot squeeze on dim {dim} for shape {dims:?}")
[INFO] [stdout]     |             ------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:98:39
[INFO] [stdout]     |
[INFO] [stdout]  90 |   macro_rules! bail {
[INFO] [stdout] ...
[INFO] [stdout]  98 |           return Err($crate::Error::Msg(format!($fmt, $($arg)*).into()).bt())
[INFO] [stdout]     |                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lazy_buffer.rs:551:13
[INFO] [stdout]     |
[INFO] [stdout] 551 | /             bail!(
[INFO] [stdout] 552 | |                 "cannot reshape between {:?} ({src_nel} elts) and {s:?} ({dst_nel} elts)",
[INFO] [stdout] 553 | |                 self.shape()
[INFO] [stdout] 554 | |             )
[INFO] [stdout]     | |_____________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lazy_buffer.rs:572:13
[INFO] [stdout]     |
[INFO] [stdout] 572 |             bail!("cannot narrow, offset {offset} + length {length} > size {dim}")
[INFO] [stdout]     |             ---------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:98:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout] ...
[INFO] [stdout]  98 |         return Err($crate::Error::Msg(format!($fmt, $($arg)*).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lazy_buffer.rs:594:13
[INFO] [stdout]     |
[INFO] [stdout] 594 |             bail!("target shape {s:?} has less dimensions than original shape {:?}", self.shape())
[INFO] [stdout]     |             -------------------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:98:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout] ...
[INFO] [stdout]  98 |         return Err($crate::Error::Msg(format!($fmt, $($arg)*).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lazy_buffer.rs:604:21
[INFO] [stdout]     |
[INFO] [stdout] 604 |                     bail!("cannot broadcast from {:?} to {s:?}", self.shape)
[INFO] [stdout]     |                     -------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lazy_buffer.rs:649:23
[INFO] [stdout]     |
[INFO] [stdout] 649 |             Err(_) => bail!("unable to create const for {c:?}"),
[INFO] [stdout]     |                       ----------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:98:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout] ...
[INFO] [stdout]  98 |         return Err($crate::Error::Msg(format!($fmt, $($arg)*).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lazy_buffer.rs:672:13
[INFO] [stdout]     |
[INFO] [stdout] 672 |             bail!("unexpected number of elements {} for shape {s:?}", data.len())
[INFO] [stdout]     |             --------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:98:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout] ...
[INFO] [stdout]  98 |         return Err($crate::Error::Msg(format!($fmt, $($arg)*).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lazy_buffer.rs:698:13
[INFO] [stdout]     |
[INFO] [stdout] 698 |             bail!("unexpected number of elements {} for shape {s:?}", data.len())
[INFO] [stdout]     |             --------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lazy_buffer.rs:724:13
[INFO] [stdout]     |
[INFO] [stdout] 724 |             bail!("empty list in cat")
[INFO] [stdout]     |             -------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lazy_buffer.rs:736:17
[INFO] [stdout]     |
[INFO] [stdout] 736 |                 bail!("mismatch between dtypes in cat, shapes: {shapes:?}")
[INFO] [stdout]     |                 ----------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lazy_buffer.rs:740:17
[INFO] [stdout]     |
[INFO] [stdout] 740 |                 bail!("mismatch between ranks in cat, shapes: {shapes:?}")
[INFO] [stdout]     |                 ---------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:98:39
[INFO] [stdout]     |
[INFO] [stdout]  90 |   macro_rules! bail {
[INFO] [stdout] ...
[INFO] [stdout]  98 |           return Err($crate::Error::Msg(format!($fmt, $($arg)*).into()).bt())
[INFO] [stdout]     |                                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lazy_buffer.rs:745:21
[INFO] [stdout]     |
[INFO] [stdout] 745 | /                     bail!(
[INFO] [stdout] 746 | |                         "mismatch between shapes in cat on dim {dim}, arg0: {:?}, arg{arg_idx}: {:?}",
[INFO] [stdout] 747 | |                         arg0.shape(),
[INFO] [stdout] 748 | |                         arg.shape()
[INFO] [stdout] 749 | |                     )
[INFO] [stdout]     | |_____________________- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]   --> src/error.rs:92:39
[INFO] [stdout]    |
[INFO] [stdout] 90 | macro_rules! bail {
[INFO] [stdout] 91 |     ($msg:literal $(,)?) => {
[INFO] [stdout] 92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]    |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/lower.rs:24:31
[INFO] [stdout]    |
[INFO] [stdout] 24 |             E::Range(_, _) => crate::bail!("TODO range is not supported yet"),
[INFO] [stdout]    |                               ----------------------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]   --> src/error.rs:98:39
[INFO] [stdout]    |
[INFO] [stdout] 90 | macro_rules! bail {
[INFO] [stdout] ...
[INFO] [stdout] 98 |         return Err($crate::Error::Msg(format!($fmt, $($arg)*).into()).bt())
[INFO] [stdout]    |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/lower.rs:52:21
[INFO] [stdout]    |
[INFO] [stdout] 52 |             None => crate::bail!("unknown arg {:?}", self.ptr().id()),
[INFO] [stdout]    |                     ------------------------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lower.rs:150:40
[INFO] [stdout]     |
[INFO] [stdout] 150 |                 ssa::Type::Value(_) => crate::bail!("non-pointer arguments are not supported yet"),
[INFO] [stdout]     |                                        ----------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:98:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout] ...
[INFO] [stdout]  98 |         return Err($crate::Error::Msg(format!($fmt, $($arg)*).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lower_op.rs:139:25
[INFO] [stdout]     |
[INFO] [stdout] 139 |                         bail!("unexpected dim for broadcast, {dim} {:?}", shape)
[INFO] [stdout]     |                         -------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:98:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout] ...
[INFO] [stdout]  98 |         return Err($crate::Error::Msg(format!($fmt, $($arg)*).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lower_op.rs:149:21
[INFO] [stdout]     |
[INFO] [stdout] 149 |                     bail!("unexpected dim for narrow, {dim} {:?}", shape)
[INFO] [stdout]     |                     ----------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:98:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout] ...
[INFO] [stdout]  98 |         return Err($crate::Error::Msg(format!($fmt, $($arg)*).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lower_op.rs:155:21
[INFO] [stdout]     |
[INFO] [stdout] 155 |                     bail!("unexpected dims for transpose {dim1} {dim2}, {:?}", shape)
[INFO] [stdout]     |                     ----------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lower_op.rs:161:21
[INFO] [stdout]     |
[INFO] [stdout] 161 |                     bail!("unexpected split dim {dim} src {shape:?}")
[INFO] [stdout]     |                     ------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lower_op.rs:164:21
[INFO] [stdout]     |
[INFO] [stdout] 164 |                     bail!("unexpected split dims {lhs}x{rhs} dst {shape:?}")
[INFO] [stdout]     |                     -------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lower_op.rs:180:21
[INFO] [stdout]     |
[INFO] [stdout] 180 |                     bail!("unexpected merge dim {dim} dst {shape:?}")
[INFO] [stdout]     |                     ------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lower_op.rs:183:21
[INFO] [stdout]     |
[INFO] [stdout] 183 |                     bail!("unexpected merge dims {lhs}x{rhs} src {arg_shape:?}")
[INFO] [stdout]     |                     ------------------------------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lower_op.rs:209:13
[INFO] [stdout]     |
[INFO] [stdout] 209 |             bail!("len mismatch between strides {self:?} and idxs {idxs:?}")
[INFO] [stdout]     |             ---------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lower_op.rs:317:29
[INFO] [stdout]     |
[INFO] [stdout] 317 |                     None => bail!("unknown arg {src:?}"),
[INFO] [stdout]     |                             ---------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:98:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout] ...
[INFO] [stdout]  98 |         return Err($crate::Error::Msg(format!($fmt, $($arg)*).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lower_op.rs:372:29
[INFO] [stdout]     |
[INFO] [stdout] 372 | ...                   bail!("unexpected dim for reduce, {dim} {:?}", self.shape)
[INFO] [stdout]     |                       ---------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lower_op.rs:415:40
[INFO] [stdout]     |
[INFO] [stdout] 415 |                 ssa::Type::Value(_) => bail!("non-pointer arguments are not supported yet"),
[INFO] [stdout]     |                                        ---------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lower_op.rs:431:25
[INFO] [stdout]     |
[INFO] [stdout] 431 |                 None => bail!("unknown arg {dst:?}"),
[INFO] [stdout]     |                         ---------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lower_op.rs:507:37
[INFO] [stdout]     |
[INFO] [stdout] 507 |                 A::Reduce { .. } => bail!("unexpected result in optimize step"),
[INFO] [stdout]     |                                     ------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/lower_op.rs:515:29
[INFO] [stdout]     |
[INFO] [stdout] 515 | ...                   bail!("unexpected layout op {op:?}")
[INFO] [stdout]     |                       ------------------------------------ in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]   --> src/error.rs:92:39
[INFO] [stdout]    |
[INFO] [stdout] 90 | macro_rules! bail {
[INFO] [stdout] 91 |     ($msg:literal $(,)?) => {
[INFO] [stdout] 92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]    |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/safetensors.rs:92:22
[INFO] [stdout]    |
[INFO] [stdout] 92 |             dtype => crate::bail!("unsupported dtype for {name}: {dtype:?}"),
[INFO] [stdout]    |                      ------------------------------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/safetensors.rs:134:22
[INFO] [stdout]     |
[INFO] [stdout] 134 |             dtype => crate::bail!("unsupported dtype for {name}: {dtype:?}"),
[INFO] [stdout]     |                      ------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]   --> src/error.rs:92:39
[INFO] [stdout]    |
[INFO] [stdout] 90 | macro_rules! bail {
[INFO] [stdout] 91 |     ($msg:literal $(,)?) => {
[INFO] [stdout] 92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]    |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/samples.rs:75:13
[INFO] [stdout]    |
[INFO] [stdout] 75 |             crate::bail!("last-dim {dim2} must be divisible by block size {block_size}")
[INFO] [stdout]    |             ---------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/samples.rs:187:13
[INFO] [stdout]     |
[INFO] [stdout] 187 |             crate::bail!("last-dim {dim2} must be divisible by block size {block_size}")
[INFO] [stdout]     |             ---------------------------------------------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]   --> src/error.rs:92:39
[INFO] [stdout]    |
[INFO] [stdout] 90 | macro_rules! bail {
[INFO] [stdout] 91 |     ($msg:literal $(,)?) => {
[INFO] [stdout] 92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]    |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/schedule.rs:74:21
[INFO] [stdout]    |
[INFO] [stdout] 74 |             None => crate::bail!("no arg for id {arg_id:?}"),
[INFO] [stdout]    |                     ---------------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]   --> src/error.rs:92:39
[INFO] [stdout]    |
[INFO] [stdout] 90 | macro_rules! bail {
[INFO] [stdout] 91 |     ($msg:literal $(,)?) => {
[INFO] [stdout] 92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]    |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]   ::: src/schedule.rs:80:13
[INFO] [stdout]    |
[INFO] [stdout] 80 |             crate::bail!("no buffers provided")
[INFO] [stdout]    |             ----------------------------------- in this macro invocation
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/error.rs:92:39
[INFO] [stdout]     |
[INFO] [stdout]  90 | macro_rules! bail {
[INFO] [stdout]  91 |     ($msg:literal $(,)?) => {
[INFO] [stdout]  92 |         return Err($crate::Error::Msg(format!($msg).into()).bt())
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]    ::: src/schedule.rs:323:21
[INFO] [stdout]     |
[INFO] [stdout] 323 |             None => crate::bail!("no arg for id {arg_id:?}"),
[INFO] [stdout]     |                     ---------------------------------------- in this macro invocation
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: you can instead use the fully-qualified path `<String as Into<String>::into(val) to avoid triggering this lint
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] running `Command { std: "docker" "inspect" "90ff1ec0a00f6e8db94c3e50d72b958cef409645a9d41fe66b7e2d0d719ae206", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "90ff1ec0a00f6e8db94c3e50d72b958cef409645a9d41fe66b7e2d0d719ae206", kill_on_drop: false }`
[INFO] [stdout] 90ff1ec0a00f6e8db94c3e50d72b958cef409645a9d41fe66b7e2d0d719ae206
