[INFO] fetching crate sf-nano-core 0.6.0...
[INFO] checking sf-nano-core-0.6.0 against a5689b034ad287112f709693384a37f1377eb9cc for pr-129249-3
[INFO] extracting crate sf-nano-core 0.6.0 into /workspace/builds/worker-1-tc2/source
[INFO] started tweaking crates.io crate sf-nano-core 0.6.0
[INFO] removed 0 missing examples
[INFO] removed 0 missing tests
[INFO] finished tweaking crates.io crate sf-nano-core 0.6.0
[INFO] tweaked toml for crates.io crate sf-nano-core 0.6.0 written to /workspace/builds/worker-1-tc2/source/Cargo.toml
[INFO] validating manifest of crates.io crate sf-nano-core 0.6.0 on toolchain a5689b034ad287112f709693384a37f1377eb9cc
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "metadata" "--manifest-path" "Cargo.toml" "--no-deps", kill_on_drop: false }`
[INFO] crate crates.io crate sf-nano-core 0.6.0 already has a lockfile, it will not be regenerated
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "fetch" "--manifest-path" "Cargo.toml", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-1-tc2/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-1-tc2/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/cargo-home:/opt/rustwide/cargo-home:ro,Z" "-v" "/var/lib/crater-agent-workspace/rustup-home:/opt/rustwide/rustup-home:ro,Z" "-m" "1610612736" "--network" "none" "ghcr.io/rust-lang/crates-build-env/linux@sha256:77db811e55d90add9212f6832c23229e3de5f1c1f9905e8cb07319ea15df73ac" "sleep" "infinity", kill_on_drop: false }`
[INFO] [stdout] 778eba989f8adf1b6b797fe313d7e3115c4f627fe2a6751a995a645206829499
[INFO] running `Command { std: "docker" "start" "778eba989f8adf1b6b797fe313d7e3115c4f627fe2a6751a995a645206829499", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "778eba989f8adf1b6b797fe313d7e3115c4f627fe2a6751a995a645206829499", 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" "778eba989f8adf1b6b797fe313d7e3115c4f627fe2a6751a995a645206829499" "/opt/rustwide/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "778eba989f8adf1b6b797fe313d7e3115c4f627fe2a6751a995a645206829499", 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" "778eba989f8adf1b6b797fe313d7e3115c4f627fe2a6751a995a645206829499" "/opt/rustwide/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "check" "--frozen" "--all" "--all-targets" "--message-format=json", kill_on_drop: false }`
[INFO] [stderr]     Checking leb128fmt v0.1.0
[INFO] [stderr]     Checking bumpalo v3.20.2
[INFO] [stderr]    Compiling sf-nano-core v0.6.0 (/opt/rustwide/workdir)
[INFO] [stderr]     Checking sf-nano-tracked-alloc v0.6.0
[INFO] [stderr]     Checking wasm-encoder v0.246.2
[INFO] [stderr]     Checking wast v246.0.2
[INFO] [stderr]     Checking wat v1.246.2
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/module/parser.rs:287:17
[INFO] [stdout]     |
[INFO] [stdout] 287 |                 "data count and data section have inconsistent lengths".into(),
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: `#[deny(self_type_conversion)]` on by default
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 287 -                 "data count and data section have inconsistent lengths".into(),
[INFO] [stdout] 287 +                 "data count and data section have inconsistent lengths",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 287 -                 "data count and data section have inconsistent lengths".into(),
[INFO] [stdout] 287 +                 <&str as Into<_>>::into("data count and data section have inconsistent lengths"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/module/parser.rs:518:17
[INFO] [stdout]     |
[INFO] [stdout] 518 |                 "malformed global mutable value".into(),
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 518 -                 "malformed global mutable value".into(),
[INFO] [stdout] 518 +                 "malformed global mutable value",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 518 -                 "malformed global mutable value".into(),
[INFO] [stdout] 518 +                 <&str as Into<_>>::into("malformed global mutable value"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/module/validator/expressions.rs:107:29
[INFO] [stdout]     |
[INFO] [stdout] 107 | ...                   "Invalid function index for ref.func".into(),
[INFO] [stdout]     |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 107 -                             "Invalid function index for ref.func".into(),
[INFO] [stdout] 107 +                             "Invalid function index for ref.func",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 107 -                             "Invalid function index for ref.func".into(),
[INFO] [stdout] 107 +                             <&str as Into<_>>::into("Invalid function index for ref.func"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/module/validator/expressions.rs:121:29
[INFO] [stdout]     |
[INFO] [stdout] 121 | ...                   "constant expression cannot reference mutable global".into(),
[INFO] [stdout]     |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 121 -                             "constant expression cannot reference mutable global".into(),
[INFO] [stdout] 121 +                             "constant expression cannot reference mutable global",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 121 -                             "constant expression cannot reference mutable global".into(),
[INFO] [stdout] 121 +                             <&str as Into<_>>::into("constant expression cannot reference mutable global"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/module/validator/expressions.rs:138:29
[INFO] [stdout]     |
[INFO] [stdout] 138 | ...                   "Not enough operands for binary operation".into(),
[INFO] [stdout]     |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 138 -                             "Not enough operands for binary operation".into(),
[INFO] [stdout] 138 +                             "Not enough operands for binary operation",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 138 -                             "Not enough operands for binary operation".into(),
[INFO] [stdout] 138 +                             <&str as Into<_>>::into("Not enough operands for binary operation"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/module/validator/expressions.rs:145:29
[INFO] [stdout]     |
[INFO] [stdout] 145 | ...                   "Type mismatch in i32 binary operation".into(),
[INFO] [stdout]     |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 145 -                             "Type mismatch in i32 binary operation".into(),
[INFO] [stdout] 145 +                             "Type mismatch in i32 binary operation",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 145 -                             "Type mismatch in i32 binary operation".into(),
[INFO] [stdout] 145 +                             <&str as Into<_>>::into("Type mismatch in i32 binary operation"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/module/validator/expressions.rs:153:29
[INFO] [stdout]     |
[INFO] [stdout] 153 | ...                   "Not enough operands for binary operation".into(),
[INFO] [stdout]     |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 153 -                             "Not enough operands for binary operation".into(),
[INFO] [stdout] 153 +                             "Not enough operands for binary operation",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 153 -                             "Not enough operands for binary operation".into(),
[INFO] [stdout] 153 +                             <&str as Into<_>>::into("Not enough operands for binary operation"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/module/validator/expressions.rs:160:29
[INFO] [stdout]     |
[INFO] [stdout] 160 | ...                   "Type mismatch in i64 binary operation".into(),
[INFO] [stdout]     |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 160 -                             "Type mismatch in i64 binary operation".into(),
[INFO] [stdout] 160 +                             "Type mismatch in i64 binary operation",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 160 -                             "Type mismatch in i64 binary operation".into(),
[INFO] [stdout] 160 +                             <&str as Into<_>>::into("Type mismatch in i64 binary operation"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/module/validator/expressions.rs:371:29
[INFO] [stdout]     |
[INFO] [stdout] 371 | ...                   "Invalid stack length at the end of the code".into(),
[INFO] [stdout]     |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 371 -                             "Invalid stack length at the end of the code".into(),
[INFO] [stdout] 371 +                             "Invalid stack length at the end of the code",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 371 -                             "Invalid stack length at the end of the code".into(),
[INFO] [stdout] 371 +                             <&str as Into<_>>::into("Invalid stack length at the end of the code"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/module/validator/functions.rs:670:25
[INFO] [stdout]     |
[INFO] [stdout] 670 |                         "if without else should keep the stack consistent".into(),
[INFO] [stdout]     |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 670 -                         "if without else should keep the stack consistent".into(),
[INFO] [stdout] 670 +                         "if without else should keep the stack consistent",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 670 -                         "if without else should keep the stack consistent".into(),
[INFO] [stdout] 670 +                         <&str as Into<_>>::into("if without else should keep the stack consistent"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/module/validator/functions.rs:846:25
[INFO] [stdout]     |
[INFO] [stdout] 846 |                         "SELECT requires both operands to be numbers or both be vectors".into(),
[INFO] [stdout]     |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 846 -                         "SELECT requires both operands to be numbers or both be vectors".into(),
[INFO] [stdout] 846 +                         "SELECT requires both operands to be numbers or both be vectors",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 846 -                         "SELECT requires both operands to be numbers or both be vectors".into(),
[INFO] [stdout] 846 +                         <&str as Into<_>>::into("SELECT requires both operands to be numbers or both be vectors"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/module/validator/functions.rs:1216:25
[INFO] [stdout]      |
[INFO] [stdout] 1216 |                         "invalid memory init memory index".into(),
[INFO] [stdout]      |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1216 -                         "invalid memory init memory index".into(),
[INFO] [stdout] 1216 +                         "invalid memory init memory index",
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1216 -                         "invalid memory init memory index".into(),
[INFO] [stdout] 1216 +                         <&str as Into<_>>::into("invalid memory init memory index"),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/module/validator/functions.rs:1221:25
[INFO] [stdout]      |
[INFO] [stdout] 1221 |                         "memory.init requires a datacount section".into(),
[INFO] [stdout]      |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1221 -                         "memory.init requires a datacount section".into(),
[INFO] [stdout] 1221 +                         "memory.init requires a datacount section",
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1221 -                         "memory.init requires a datacount section".into(),
[INFO] [stdout] 1221 +                         <&str as Into<_>>::into("memory.init requires a datacount section"),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/module/validator/functions.rs:1239:25
[INFO] [stdout]      |
[INFO] [stdout] 1239 |                         "invalid memory copy destination memory index".into(),
[INFO] [stdout]      |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1239 -                         "invalid memory copy destination memory index".into(),
[INFO] [stdout] 1239 +                         "invalid memory copy destination memory index",
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1239 -                         "invalid memory copy destination memory index".into(),
[INFO] [stdout] 1239 +                         <&str as Into<_>>::into("invalid memory copy destination memory index"),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/module/validator/functions.rs:1244:25
[INFO] [stdout]      |
[INFO] [stdout] 1244 |                         "invalid memory copy source memory index".into(),
[INFO] [stdout]      |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1244 -                         "invalid memory copy source memory index".into(),
[INFO] [stdout] 1244 +                         "invalid memory copy source memory index",
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1244 -                         "invalid memory copy source memory index".into(),
[INFO] [stdout] 1244 +                         <&str as Into<_>>::into("invalid memory copy source memory index"),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/module/validator/functions.rs:1264:25
[INFO] [stdout]      |
[INFO] [stdout] 1264 |                         "invalid memory fill memory index".into(),
[INFO] [stdout]      |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1264 -                         "invalid memory fill memory index".into(),
[INFO] [stdout] 1264 +                         "invalid memory fill memory index",
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1264 -                         "invalid memory fill memory index".into(),
[INFO] [stdout] 1264 +                         <&str as Into<_>>::into("invalid memory fill memory index"),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/module/validator/functions.rs:1281:25
[INFO] [stdout]      |
[INFO] [stdout] 1281 |                         "data.drop requires a datacount section".into(),
[INFO] [stdout]      |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1281 -                         "data.drop requires a datacount section".into(),
[INFO] [stdout] 1281 +                         "data.drop requires a datacount section",
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1281 -                         "data.drop requires a datacount section".into(),
[INFO] [stdout] 1281 +                         <&str as Into<_>>::into("data.drop requires a datacount section"),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/module/validator/functions.rs:1300:25
[INFO] [stdout]      |
[INFO] [stdout] 1300 |                         "invalid table init element index".into(),
[INFO] [stdout]      |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1300 -                         "invalid table init element index".into(),
[INFO] [stdout] 1300 +                         "invalid table init element index",
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1300 -                         "invalid table init element index".into(),
[INFO] [stdout] 1300 +                         <&str as Into<_>>::into("invalid table init element index"),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/module/validator/functions.rs:2471:17
[INFO] [stdout]      |
[INFO] [stdout] 2471 |                 "popping value while control frame stack is empty".into(),
[INFO] [stdout]      |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2471 -                 "popping value while control frame stack is empty".into(),
[INFO] [stdout] 2471 +                 "popping value while control frame stack is empty",
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2471 -                 "popping value while control frame stack is empty".into(),
[INFO] [stdout] 2471 +                 <&str as Into<_>>::into("popping value while control frame stack is empty"),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/module/validator/functions.rs:2547:17
[INFO] [stdout]      |
[INFO] [stdout] 2547 |                 "cannot pop from an empty control frame stack".into(),
[INFO] [stdout]      |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2547 -                 "cannot pop from an empty control frame stack".into(),
[INFO] [stdout] 2547 +                 "cannot pop from an empty control frame stack",
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2547 -                 "cannot pop from an empty control frame stack".into(),
[INFO] [stdout] 2547 +                 <&str as Into<_>>::into("cannot pop from an empty control frame stack"),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/module/validator/mod.rs:204:25
[INFO] [stdout]     |
[INFO] [stdout] 204 |                         "element offset expression must return i32".into(),
[INFO] [stdout]     |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 204 -                         "element offset expression must return i32".into(),
[INFO] [stdout] 204 +                         "element offset expression must return i32",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 204 -                         "element offset expression must return i32".into(),
[INFO] [stdout] 204 +                         <&str as Into<_>>::into("element offset expression must return i32"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<dyn Fn(&mut Caller<'a>, &[Value], &mut [Value]) -> Result<(), _>>`
[INFO] [stdout]    --> src/vm/entities.rs:100:45
[INFO] [stdout]     |
[INFO] [stdout] 100 |         let callback: Rc<DynHostCallback> = callback.into();
[INFO] [stdout]     |                                             ^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: the full name for the type has been written to '/opt/rustwide/target/debug/build/sf-nano-core/ca9c5e54073c3f56/out/sf_nano_core-ca9c5e54073c3f56.long-type-13714461375334848845.txt'
[INFO] [stdout]     = note: consider using `--verbose` to print the full type name to the console
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 100 -         let callback: Rc<DynHostCallback> = callback.into();
[INFO] [stdout] 100 +         let callback: Rc<DynHostCallback> = callback;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 100 -         let callback: Rc<DynHostCallback> = callback.into();
[INFO] [stdout] 100 +         let callback: Rc<DynHostCallback> = <Rc<dyn for<'b, 'a, 'c, 'd> Fn(&'b mut Caller<'a>, &'c [vm::value::Value], &'d mut [vm::value::Value]) -> Result<(), WasmError>> as Into<_>>::into(callback);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<InstanceTableInner>`
[INFO] [stdout]    --> src/vm/link.rs:406:23
[INFO] [stdout]     |
[INFO] [stdout] 406 |         InstanceTable(table.into()).checkout(id)
[INFO] [stdout]     |                       ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 406 -         InstanceTable(table.into()).checkout(id)
[INFO] [stdout] 406 +         InstanceTable(table).checkout(id)
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 406 -         InstanceTable(table.into()).checkout(id)
[INFO] [stdout] 406 +         InstanceTable(<Rc<InstanceTableInner> as Into<_>>::into(table)).checkout(id)
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<InstanceTableInner>`
[INFO] [stdout]    --> src/vm/link.rs:418:23
[INFO] [stdout]     |
[INFO] [stdout] 418 |         InstanceTable(table.into()).checkout(id)
[INFO] [stdout]     |                       ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 418 -         InstanceTable(table.into()).checkout(id)
[INFO] [stdout] 418 +         InstanceTable(table).checkout(id)
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 418 -         InstanceTable(table.into()).checkout(id)
[INFO] [stdout] 418 +         InstanceTable(<Rc<InstanceTableInner> as Into<_>>::into(table)).checkout(id)
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<InstanceTableInner>`
[INFO] [stdout]    --> src/vm/link.rs:424:28
[INFO] [stdout]     |
[INFO] [stdout] 424 |         Some(InstanceTable(table.into()))
[INFO] [stdout]     |                            ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 424 -         Some(InstanceTable(table.into()))
[INFO] [stdout] 424 +         Some(InstanceTable(table))
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 424 -         Some(InstanceTable(table.into()))
[INFO] [stdout] 424 +         Some(InstanceTable(<Rc<InstanceTableInner> as Into<_>>::into(table)))
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Vec<machine_ir::types::MachineValue>`
[INFO] [stdout]    --> src/vm/jit/arch/common/core.rs:505:19
[INFO] [stdout]     |
[INFO] [stdout] 505 |             args: args.to_vec().into(),
[INFO] [stdout]     |                   ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 505 -             args: args.to_vec().into(),
[INFO] [stdout] 505 +             args: args.to_vec(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 505 -             args: args.to_vec().into(),
[INFO] [stdout] 505 +             args: <Vec<machine_ir::types::MachineValue> as Into<_>>::into(args.to_vec()),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/arch/x86_64/backend.rs:748:21
[INFO] [stdout]     |
[INFO] [stdout] 748 |                     "x86_64 GP move requested for FP storage type".into(),
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 748 -                     "x86_64 GP move requested for FP storage type".into(),
[INFO] [stdout] 748 +                     "x86_64 GP move requested for FP storage type",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 748 -                     "x86_64 GP move requested for FP storage type".into(),
[INFO] [stdout] 748 +                     <&str as Into<_>>::into("x86_64 GP move requested for FP storage type"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/arch/x86_64/backend.rs:770:21
[INFO] [stdout]     |
[INFO] [stdout] 770 |                     "x86_64 GP cmov requested for FP storage type".into(),
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 770 -                     "x86_64 GP cmov requested for FP storage type".into(),
[INFO] [stdout] 770 +                     "x86_64 GP cmov requested for FP storage type",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 770 -                     "x86_64 GP cmov requested for FP storage type".into(),
[INFO] [stdout] 770 +                     <&str as Into<_>>::into("x86_64 GP cmov requested for FP storage type"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/arch/x86_64/control.rs:523:17
[INFO] [stdout]     |
[INFO] [stdout] 523 |                 "x86_64 cannot lower 32-bit GP pair scalar return".into(),
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 523 -                 "x86_64 cannot lower 32-bit GP pair scalar return".into(),
[INFO] [stdout] 523 +                 "x86_64 cannot lower 32-bit GP pair scalar return",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 523 -                 "x86_64 cannot lower 32-bit GP pair scalar return".into(),
[INFO] [stdout] 523 +                 <&str as Into<_>>::into("x86_64 cannot lower 32-bit GP pair scalar return"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/arch/x86_64/control.rs:654:46
[INFO] [stdout]     |
[INFO] [stdout] 654 |             .map_err(|_| WasmError::internal("x86_64 call frame delta exceeds i32".into()))?;
[INFO] [stdout]     |                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 654 -             .map_err(|_| WasmError::internal("x86_64 call frame delta exceeds i32".into()))?;
[INFO] [stdout] 654 +             .map_err(|_| WasmError::internal("x86_64 call frame delta exceeds i32"))?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 654 -             .map_err(|_| WasmError::internal("x86_64 call frame delta exceeds i32".into()))?;
[INFO] [stdout] 654 +             .map_err(|_| WasmError::internal(<&str as Into<_>>::into("x86_64 call frame delta exceeds i32")))?;
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/arch/x86_64/control.rs:675:17
[INFO] [stdout]     |
[INFO] [stdout] 675 |                 "x86_64 cannot lower 32-bit GP pair scalar call result".into(),
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 675 -                 "x86_64 cannot lower 32-bit GP pair scalar call result".into(),
[INFO] [stdout] 675 +                 "x86_64 cannot lower 32-bit GP pair scalar call result",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 675 -                 "x86_64 cannot lower 32-bit GP pair scalar call result".into(),
[INFO] [stdout] 675 +                 <&str as Into<_>>::into("x86_64 cannot lower 32-bit GP pair scalar call result"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/arch/x86_64/control.rs:840:17
[INFO] [stdout]     |
[INFO] [stdout] 840 |                 "x86_64 MachineIR jump table requires at least one entry".into(),
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 840 -                 "x86_64 MachineIR jump table requires at least one entry".into(),
[INFO] [stdout] 840 +                 "x86_64 MachineIR jump table requires at least one entry",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 840 -                 "x86_64 MachineIR jump table requires at least one entry".into(),
[INFO] [stdout] 840 +                 <&str as Into<_>>::into("x86_64 MachineIR jump table requires at least one entry"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/arch/x86_64/inst.rs:107:17
[INFO] [stdout]     |
[INFO] [stdout] 107 |                 "x86_64 backend received Int64PairBinary; 32-bit legalized MachineIR should not reach x86_64 codegen".into(),
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 107 -                 "x86_64 backend received Int64PairBinary; 32-bit legalized MachineIR should not reach x86_64 codegen".into(),
[INFO] [stdout] 107 +                 "x86_64 backend received Int64PairBinary; 32-bit legalized MachineIR should not reach x86_64 codegen",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 107 -                 "x86_64 backend received Int64PairBinary; 32-bit legalized MachineIR should not reach x86_64 codegen".into(),
[INFO] [stdout] 107 +                 <&str as Into<_>>::into("x86_64 backend received Int64PairBinary; 32-bit legalized MachineIR should not reach x86_64 codegen"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/arch/x86_64/inst.rs:110:17
[INFO] [stdout]     |
[INFO] [stdout] 110 |                 "x86_64 backend received Int64PairUnary; 32-bit legalized MachineIR should not reach x86_64 codegen".into(),
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 110 -                 "x86_64 backend received Int64PairUnary; 32-bit legalized MachineIR should not reach x86_64 codegen".into(),
[INFO] [stdout] 110 +                 "x86_64 backend received Int64PairUnary; 32-bit legalized MachineIR should not reach x86_64 codegen",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 110 -                 "x86_64 backend received Int64PairUnary; 32-bit legalized MachineIR should not reach x86_64 codegen".into(),
[INFO] [stdout] 110 +                 <&str as Into<_>>::into("x86_64 backend received Int64PairUnary; 32-bit legalized MachineIR should not reach x86_64 codegen"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/arch/x86_64/inst.rs:113:17
[INFO] [stdout]     |
[INFO] [stdout] 113 |                 "x86_64 backend received Int64PairDivRem; 32-bit legalized MachineIR should not reach x86_64 codegen".into(),
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 113 -                 "x86_64 backend received Int64PairDivRem; 32-bit legalized MachineIR should not reach x86_64 codegen".into(),
[INFO] [stdout] 113 +                 "x86_64 backend received Int64PairDivRem; 32-bit legalized MachineIR should not reach x86_64 codegen",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 113 -                 "x86_64 backend received Int64PairDivRem; 32-bit legalized MachineIR should not reach x86_64 codegen".into(),
[INFO] [stdout] 113 +                 <&str as Into<_>>::into("x86_64 backend received Int64PairDivRem; 32-bit legalized MachineIR should not reach x86_64 codegen"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/arch/x86_64/inst.rs:116:17
[INFO] [stdout]     |
[INFO] [stdout] 116 |                 "x86_64 backend received Int64PairShift; 32-bit legalized MachineIR should not reach x86_64 codegen".into(),
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 116 -                 "x86_64 backend received Int64PairShift; 32-bit legalized MachineIR should not reach x86_64 codegen".into(),
[INFO] [stdout] 116 +                 "x86_64 backend received Int64PairShift; 32-bit legalized MachineIR should not reach x86_64 codegen",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 116 -                 "x86_64 backend received Int64PairShift; 32-bit legalized MachineIR should not reach x86_64 codegen".into(),
[INFO] [stdout] 116 +                 <&str as Into<_>>::into("x86_64 backend received Int64PairShift; 32-bit legalized MachineIR should not reach x86_64 codegen"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/arch/x86_64/inst.rs:119:17
[INFO] [stdout]     |
[INFO] [stdout] 119 |                 "x86_64 backend received Int64MulFromSignExt32; this peephole only fires on 32-bit GP backends".into(),
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 119 -                 "x86_64 backend received Int64MulFromSignExt32; this peephole only fires on 32-bit GP backends".into(),
[INFO] [stdout] 119 +                 "x86_64 backend received Int64MulFromSignExt32; this peephole only fires on 32-bit GP backends",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 119 -                 "x86_64 backend received Int64MulFromSignExt32; this peephole only fires on 32-bit GP backends".into(),
[INFO] [stdout] 119 +                 <&str as Into<_>>::into("x86_64 backend received Int64MulFromSignExt32; this peephole only fires on 32-bit GP backends"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/arch/x86_64/inst.rs:200:17
[INFO] [stdout]     |
[INFO] [stdout] 200 |                 "x86_64 backend received ConvertI64PairToFloat; 32-bit legalized MachineIR should not reach x86_64 codegen".into(),
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 200 -                 "x86_64 backend received ConvertI64PairToFloat; 32-bit legalized MachineIR should not reach x86_64 codegen".into(),
[INFO] [stdout] 200 +                 "x86_64 backend received ConvertI64PairToFloat; 32-bit legalized MachineIR should not reach x86_64 codegen",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 200 -                 "x86_64 backend received ConvertI64PairToFloat; 32-bit legalized MachineIR should not reach x86_64 codegen".into(),
[INFO] [stdout] 200 +                 <&str as Into<_>>::into("x86_64 backend received ConvertI64PairToFloat; 32-bit legalized MachineIR should not reach x86_64 codegen"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/arch/x86_64/inst.rs:203:17
[INFO] [stdout]     |
[INFO] [stdout] 203 |                 "x86_64 backend received Int64PairCompare; 32-bit legalized MachineIR should not reach x86_64 codegen".into(),
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 203 -                 "x86_64 backend received Int64PairCompare; 32-bit legalized MachineIR should not reach x86_64 codegen".into(),
[INFO] [stdout] 203 +                 "x86_64 backend received Int64PairCompare; 32-bit legalized MachineIR should not reach x86_64 codegen",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 203 -                 "x86_64 backend received Int64PairCompare; 32-bit legalized MachineIR should not reach x86_64 codegen".into(),
[INFO] [stdout] 203 +                 <&str as Into<_>>::into("x86_64 backend received Int64PairCompare; 32-bit legalized MachineIR should not reach x86_64 codegen"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/arch/x86_64/inst.rs:206:17
[INFO] [stdout]     |
[INFO] [stdout] 206 |                 "x86_64 backend received ConvertFloatToI64Pair; 32-bit legalized MachineIR should not reach x86_64 codegen".into(),
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 206 -                 "x86_64 backend received ConvertFloatToI64Pair; 32-bit legalized MachineIR should not reach x86_64 codegen".into(),
[INFO] [stdout] 206 +                 "x86_64 backend received ConvertFloatToI64Pair; 32-bit legalized MachineIR should not reach x86_64 codegen",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 206 -                 "x86_64 backend received ConvertFloatToI64Pair; 32-bit legalized MachineIR should not reach x86_64 codegen".into(),
[INFO] [stdout] 206 +                 <&str as Into<_>>::into("x86_64 backend received ConvertFloatToI64Pair; 32-bit legalized MachineIR should not reach x86_64 codegen"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/arch/x86_64/inst.rs:209:17
[INFO] [stdout]     |
[INFO] [stdout] 209 |                 "x86_64 backend received ReinterpretF64ToI64Pair; 32-bit legalized MachineIR should not reach x86_64 codegen".into(),
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 209 -                 "x86_64 backend received ReinterpretF64ToI64Pair; 32-bit legalized MachineIR should not reach x86_64 codegen".into(),
[INFO] [stdout] 209 +                 "x86_64 backend received ReinterpretF64ToI64Pair; 32-bit legalized MachineIR should not reach x86_64 codegen",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 209 -                 "x86_64 backend received ReinterpretF64ToI64Pair; 32-bit legalized MachineIR should not reach x86_64 codegen".into(),
[INFO] [stdout] 209 +                 <&str as Into<_>>::into("x86_64 backend received ReinterpretF64ToI64Pair; 32-bit legalized MachineIR should not reach x86_64 codegen"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/arch/x86_64/inst.rs:212:17
[INFO] [stdout]     |
[INFO] [stdout] 212 |                 "x86_64 backend received ReinterpretI64PairToF64; 32-bit legalized MachineIR should not reach x86_64 codegen".into(),
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 212 -                 "x86_64 backend received ReinterpretI64PairToF64; 32-bit legalized MachineIR should not reach x86_64 codegen".into(),
[INFO] [stdout] 212 +                 "x86_64 backend received ReinterpretI64PairToF64; 32-bit legalized MachineIR should not reach x86_64 codegen",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 212 -                 "x86_64 backend received ReinterpretI64PairToF64; 32-bit legalized MachineIR should not reach x86_64 codegen".into(),
[INFO] [stdout] 212 +                 <&str as Into<_>>::into("x86_64 backend received ReinterpretI64PairToF64; 32-bit legalized MachineIR should not reach x86_64 codegen"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/arch/x86_64/inst.rs:412:25
[INFO] [stdout]     |
[INFO] [stdout] 412 |                         "x86_64 backend received pair-valued struct.get".into(),
[INFO] [stdout]     |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 412 -                         "x86_64 backend received pair-valued struct.get".into(),
[INFO] [stdout] 412 +                         "x86_64 backend received pair-valued struct.get",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 412 -                         "x86_64 backend received pair-valued struct.get".into(),
[INFO] [stdout] 412 +                         <&str as Into<_>>::into("x86_64 backend received pair-valued struct.get"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/arch/x86_64/inst.rs:440:25
[INFO] [stdout]     |
[INFO] [stdout] 440 |                         "x86_64 backend received pair-valued struct.set".into(),
[INFO] [stdout]     |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 440 -                         "x86_64 backend received pair-valued struct.set".into(),
[INFO] [stdout] 440 +                         "x86_64 backend received pair-valued struct.set",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 440 -                         "x86_64 backend received pair-valued struct.set".into(),
[INFO] [stdout] 440 +                         <&str as Into<_>>::into("x86_64 backend received pair-valued struct.set"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/arch/x86_64/inst.rs:461:25
[INFO] [stdout]     |
[INFO] [stdout] 461 |                         "x86_64 backend received pair-valued array.new".into(),
[INFO] [stdout]     |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 461 -                         "x86_64 backend received pair-valued array.new".into(),
[INFO] [stdout] 461 +                         "x86_64 backend received pair-valued array.new",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 461 -                         "x86_64 backend received pair-valued array.new".into(),
[INFO] [stdout] 461 +                         <&str as Into<_>>::into("x86_64 backend received pair-valued array.new"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/arch/x86_64/inst.rs:543:25
[INFO] [stdout]     |
[INFO] [stdout] 543 |                         "x86_64 backend received pair-valued array.get".into(),
[INFO] [stdout]     |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 543 -                         "x86_64 backend received pair-valued array.get".into(),
[INFO] [stdout] 543 +                         "x86_64 backend received pair-valued array.get",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 543 -                         "x86_64 backend received pair-valued array.get".into(),
[INFO] [stdout] 543 +                         <&str as Into<_>>::into("x86_64 backend received pair-valued array.get"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/arch/x86_64/inst.rs:571:25
[INFO] [stdout]     |
[INFO] [stdout] 571 |                         "x86_64 backend received pair-valued array.set".into(),
[INFO] [stdout]     |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 571 -                         "x86_64 backend received pair-valued array.set".into(),
[INFO] [stdout] 571 +                         "x86_64 backend received pair-valued array.set",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 571 -                         "x86_64 backend received pair-valued array.set".into(),
[INFO] [stdout] 571 +                         <&str as Into<_>>::into("x86_64 backend received pair-valued array.set"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/arch/x86_64/inst.rs:593:25
[INFO] [stdout]     |
[INFO] [stdout] 593 |                         "x86_64 backend received pair-valued array.fill".into(),
[INFO] [stdout]     |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 593 -                         "x86_64 backend received pair-valued array.fill".into(),
[INFO] [stdout] 593 +                         "x86_64 backend received pair-valued array.fill",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 593 -                         "x86_64 backend received pair-valued array.fill".into(),
[INFO] [stdout] 593 +                         <&str as Into<_>>::into("x86_64 backend received pair-valued array.fill"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/arch/x86_64/inst.rs:860:21
[INFO] [stdout]     |
[INFO] [stdout] 860 | /                     "x86_64 MachineIR backend does not support narrow integer loads into FP regs"
[INFO] [stdout] 861 | |                         .into(),
[INFO] [stdout]     | |_______________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 860 -                     "x86_64 MachineIR backend does not support narrow integer loads into FP regs"
[INFO] [stdout] 861 -                         .into(),
[INFO] [stdout] 860 +                     "x86_64 MachineIR backend does not support narrow integer loads into FP regs",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 860 -                     "x86_64 MachineIR backend does not support narrow integer loads into FP regs"
[INFO] [stdout] 861 -                         .into(),
[INFO] [stdout] 860 +                     <&str as Into<_>>::into("x86_64 MachineIR backend does not support narrow integer loads into FP regs"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/arch/x86_64/inst.rs:902:21
[INFO] [stdout]     |
[INFO] [stdout] 902 |                     "x86_64 MachineIR backend does not support sign-extending 64-bit loads".into(),
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 902 -                     "x86_64 MachineIR backend does not support sign-extending 64-bit loads".into(),
[INFO] [stdout] 902 +                     "x86_64 MachineIR backend does not support sign-extending 64-bit loads",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 902 -                     "x86_64 MachineIR backend does not support sign-extending 64-bit loads".into(),
[INFO] [stdout] 902 +                     <&str as Into<_>>::into("x86_64 MachineIR backend does not support sign-extending 64-bit loads"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/arch/x86_64/inst.rs:992:21
[INFO] [stdout]     |
[INFO] [stdout] 992 | /                     "x86_64 MachineIR backend does not support narrow integer loads into FP regs"
[INFO] [stdout] 993 | |                         .into(),
[INFO] [stdout]     | |_______________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 992 -                     "x86_64 MachineIR backend does not support narrow integer loads into FP regs"
[INFO] [stdout] 993 -                         .into(),
[INFO] [stdout] 992 +                     "x86_64 MachineIR backend does not support narrow integer loads into FP regs",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 992 -                     "x86_64 MachineIR backend does not support narrow integer loads into FP regs"
[INFO] [stdout] 993 -                         .into(),
[INFO] [stdout] 992 +                     <&str as Into<_>>::into("x86_64 MachineIR backend does not support narrow integer loads into FP regs"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/vm/jit/arch/x86_64/inst.rs:1038:21
[INFO] [stdout]      |
[INFO] [stdout] 1038 |                     "x86_64 MachineIR backend does not support sign-extending 64-bit loads".into(),
[INFO] [stdout]      |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1038 -                     "x86_64 MachineIR backend does not support sign-extending 64-bit loads".into(),
[INFO] [stdout] 1038 +                     "x86_64 MachineIR backend does not support sign-extending 64-bit loads",
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1038 -                     "x86_64 MachineIR backend does not support sign-extending 64-bit loads".into(),
[INFO] [stdout] 1038 +                     <&str as Into<_>>::into("x86_64 MachineIR backend does not support sign-extending 64-bit loads"),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/vm/jit/arch/x86_64/inst.rs:1070:29
[INFO] [stdout]      |
[INFO] [stdout] 1070 | ...                   "x86_64 MachineIR backend does not support narrow FP stores".into(),
[INFO] [stdout]      |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1070 -                             "x86_64 MachineIR backend does not support narrow FP stores".into(),
[INFO] [stdout] 1070 +                             "x86_64 MachineIR backend does not support narrow FP stores",
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1070 -                             "x86_64 MachineIR backend does not support narrow FP stores".into(),
[INFO] [stdout] 1070 +                             <&str as Into<_>>::into("x86_64 MachineIR backend does not support narrow FP stores"),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/vm/jit/arch/x86_64/inst.rs:1145:29
[INFO] [stdout]      |
[INFO] [stdout] 1145 | ...                   "x86_64 MachineIR backend does not support narrow FP stores".into(),
[INFO] [stdout]      |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1145 -                             "x86_64 MachineIR backend does not support narrow FP stores".into(),
[INFO] [stdout] 1145 +                             "x86_64 MachineIR backend does not support narrow FP stores",
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1145 -                             "x86_64 MachineIR backend does not support narrow FP stores".into(),
[INFO] [stdout] 1145 +                             <&str as Into<_>>::into("x86_64 MachineIR backend does not support narrow FP stores"),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/vm/jit/debug/ir_dump.rs:595:5
[INFO] [stdout]     |
[INFO] [stdout] 595 | /     bindings
[INFO] [stdout] 596 | |         .iter()
[INFO] [stdout] 597 | |         .map(|b| format!("v{}=v{}", b.param.0, b.value.0))
[INFO] [stdout] 598 | |         .collect::<collections::Vec<_>>()
[INFO] [stdout] 599 | |         .join(", ")
[INFO] [stdout] 600 | |         .into()
[INFO] [stdout]     | |_______________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 599 -         .join(", ")
[INFO] [stdout] 600 -         .into()
[INFO] [stdout] 599 +         .join(", ")
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 595 ~     <String as Into<_>>::into(bindings
[INFO] [stdout] 596 |         .iter()
[INFO] [stdout] 597 |         .map(|b| format!("v{}=v{}", b.param.0, b.value.0))
[INFO] [stdout] 598 |         .collect::<collections::Vec<_>>()
[INFO] [stdout] 599 ~         .join(", "))
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/vm/jit/debug/ir_dump.rs:604:5
[INFO] [stdout]     |
[INFO] [stdout] 604 | /     ops.iter()
[INFO] [stdout] 605 | |         .map(|op| match op.decode() {
[INFO] [stdout] 606 | |             DecodedOperand::None => String::from("_"),
[INFO] [stdout] 607 | |             DecodedOperand::Value(v) => format!("v{}", v.0),
[INFO] [stdout] ...   |
[INFO] [stdout] 614 | |         .join(", ")
[INFO] [stdout] 615 | |         .into()
[INFO] [stdout]     | |_______________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 614 -         .join(", ")
[INFO] [stdout] 615 -         .into()
[INFO] [stdout] 614 +         .join(", ")
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 604 ~     <String as Into<_>>::into(ops.iter()
[INFO] [stdout] 605 |         .map(|op| match op.decode() {
[INFO] [stdout] ...
[INFO] [stdout] 613 |         .collect::<collections::Vec<_>>()
[INFO] [stdout] 614 ~         .join(", "))
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]     --> src/vm/jit/debug/ir_dump.rs:1777:5
[INFO] [stdout]      |
[INFO] [stdout] 1777 | /     args.lane_args
[INFO] [stdout] 1778 | |         .iter()
[INFO] [stdout] 1779 | |         .map(|arg| match arg {
[INFO] [stdout] 1780 | |             MachineCallLaneArg::Gp {
[INFO] [stdout] ...    |
[INFO] [stdout] 1806 | |         .join(", ")
[INFO] [stdout] 1807 | |         .into()
[INFO] [stdout]      | |_______________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1806 -         .join(", ")
[INFO] [stdout] 1807 -         .into()
[INFO] [stdout] 1806 +         .join(", ")
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1777 ~     <String as Into<_>>::into(args.lane_args
[INFO] [stdout] 1778 |         .iter()
[INFO] [stdout]  ...
[INFO] [stdout] 1805 |         .collect::<collections::Vec<_>>()
[INFO] [stdout] 1806 ~         .join(", "))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]     --> src/vm/jit/debug/ir_dump.rs:1875:5
[INFO] [stdout]      |
[INFO] [stdout] 1875 | /     args.iter()
[INFO] [stdout] 1876 | |         .map(mval)
[INFO] [stdout] 1877 | |         .collect::<collections::Vec<_>>()
[INFO] [stdout] 1878 | |         .join(", ")
[INFO] [stdout] 1879 | |         .into()
[INFO] [stdout]      | |_______________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1878 -         .join(", ")
[INFO] [stdout] 1879 -         .into()
[INFO] [stdout] 1878 +         .join(", ")
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1875 ~     <String as Into<_>>::into(args.iter()
[INFO] [stdout] 1876 |         .map(mval)
[INFO] [stdout] 1877 |         .collect::<collections::Vec<_>>()
[INFO] [stdout] 1878 ~         .join(", "))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Vec<u8>`
[INFO] [stdout]    --> src/vm/jit/instantiate.rs:812:36
[INFO] [stdout]     |
[INFO] [stdout] 812 |             .map(|d| DataInst::new(d.get_init().to_vec().into()))
[INFO] [stdout]     |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 812 -             .map(|d| DataInst::new(d.get_init().to_vec().into()))
[INFO] [stdout] 812 +             .map(|d| DataInst::new(d.get_init().to_vec()))
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 812 -             .map(|d| DataInst::new(d.get_init().to_vec().into()))
[INFO] [stdout] 812 +             .map(|d| DataInst::new(<Vec<u8> as Into<_>>::into(d.get_init().to_vec())))
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/vm/jit/instantiate.rs:1362:55
[INFO] [stdout]      |
[INFO] [stdout] 1362 |                     .ok_or_else(|| WasmError::invalid("element function index out of range".into()))
[INFO] [stdout]      |                                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1362 -                     .ok_or_else(|| WasmError::invalid("element function index out of range".into()))
[INFO] [stdout] 1362 +                     .ok_or_else(|| WasmError::invalid("element function index out of range"))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1362 -                     .ok_or_else(|| WasmError::invalid("element function index out of range".into()))
[INFO] [stdout] 1362 +                     .ok_or_else(|| WasmError::invalid(<&str as Into<_>>::into("element function index out of range")))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/vm/jit/instantiate.rs:1374:25
[INFO] [stdout]      |
[INFO] [stdout] 1374 |                         "element init must be a reference".into(),
[INFO] [stdout]      |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1374 -                         "element init must be a reference".into(),
[INFO] [stdout] 1374 +                         "element init must be a reference",
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1374 -                         "element init must be a reference".into(),
[INFO] [stdout] 1374 +                         <&str as Into<_>>::into("element init must be a reference"),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Vec<u8>`
[INFO] [stdout]    --> src/vm/jit/machine/lower_cache_layout.rs:994:60
[INFO] [stdout]     |
[INFO] [stdout] 994 |                     let preserve: collections::Vec<Lane> = layout.to_vec().into();
[INFO] [stdout]     |                                                            ^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 994 -                     let preserve: collections::Vec<Lane> = layout.to_vec().into();
[INFO] [stdout] 994 +                     let preserve: collections::Vec<Lane> = layout.to_vec();
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 994 -                     let preserve: collections::Vec<Lane> = layout.to_vec().into();
[INFO] [stdout] 994 +                     let preserve: collections::Vec<Lane> = <Vec<u8> as Into<_>>::into(layout.to_vec());
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/vm/jit/machine/lower_cache_layout.rs:1037:25
[INFO] [stdout]      |
[INFO] [stdout] 1037 |                         "FP cache exit layout unexpectedly failed without a feasible hole".into(),
[INFO] [stdout]      |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1037 -                         "FP cache exit layout unexpectedly failed without a feasible hole".into(),
[INFO] [stdout] 1037 +                         "FP cache exit layout unexpectedly failed without a feasible hole",
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1037 -                         "FP cache exit layout unexpectedly failed without a feasible hole".into(),
[INFO] [stdout] 1037 +                         <&str as Into<_>>::into("FP cache exit layout unexpectedly failed without a feasible hole"),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Vec<u8>`
[INFO] [stdout]     --> src/vm/jit/machine/lower_cache_layout.rs:1061:64
[INFO] [stdout]      |
[INFO] [stdout] 1061 |                         let preserve: collections::Vec<Lane> = layout.to_vec().into();
[INFO] [stdout]      |                                                                ^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1061 -                         let preserve: collections::Vec<Lane> = layout.to_vec().into();
[INFO] [stdout] 1061 +                         let preserve: collections::Vec<Lane> = layout.to_vec();
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1061 -                         let preserve: collections::Vec<Lane> = layout.to_vec().into();
[INFO] [stdout] 1061 +                         let preserve: collections::Vec<Lane> = <Vec<u8> as Into<_>>::into(layout.to_vec());
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/vm/jit/machine/lower_cache_layout.rs:1104:29
[INFO] [stdout]      |
[INFO] [stdout] 1104 | / ...                   "FP cache exit layout unexpectedly failed without a feasible hole"
[INFO] [stdout] 1105 | | ...                       .into(),
[INFO] [stdout]      | |_________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1104 -                             "FP cache exit layout unexpectedly failed without a feasible hole"
[INFO] [stdout] 1105 -                                 .into(),
[INFO] [stdout] 1104 +                             "FP cache exit layout unexpectedly failed without a feasible hole",
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1104 -                             "FP cache exit layout unexpectedly failed without a feasible hole"
[INFO] [stdout] 1105 -                                 .into(),
[INFO] [stdout] 1104 +                             <&str as Into<_>>::into("FP cache exit layout unexpectedly failed without a feasible hole"),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/vm/jit/machine/lower_cache_layout.rs:1262:13
[INFO] [stdout]      |
[INFO] [stdout] 1262 |             "FP cache lane layout unexpectedly failed without a feasible hole".into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1262 -             "FP cache lane layout unexpectedly failed without a feasible hole".into(),
[INFO] [stdout] 1262 +             "FP cache lane layout unexpectedly failed without a feasible hole",
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1262 -             "FP cache lane layout unexpectedly failed without a feasible hole".into(),
[INFO] [stdout] 1262 +             <&str as Into<_>>::into("FP cache lane layout unexpectedly failed without a feasible hole"),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Vec<u8>`
[INFO] [stdout]     --> src/vm/jit/machine/lower_cache_layout.rs:1352:41
[INFO] [stdout]      |
[INFO] [stdout] 1352 |             *best = Some((current_cost, current.to_vec().into()));
[INFO] [stdout]      |                                         ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1352 -             *best = Some((current_cost, current.to_vec().into()));
[INFO] [stdout] 1352 +             *best = Some((current_cost, current.to_vec()));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1352 -             *best = Some((current_cost, current.to_vec().into()));
[INFO] [stdout] 1352 +             *best = Some((current_cost, <Vec<u8> as Into<_>>::into(current.to_vec())));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/vm/jit/machine/lower_cache_layout.rs:1585:13
[INFO] [stdout]      |
[INFO] [stdout] 1585 |             "unsupported cache lane segment width for bank".into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1585 -             "unsupported cache lane segment width for bank".into(),
[INFO] [stdout] 1585 +             "unsupported cache lane segment width for bank",
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1585 -             "unsupported cache lane segment width for bank".into(),
[INFO] [stdout] 1585 +             <&str as Into<_>>::into("unsupported cache lane segment width for bank"),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/vm/jit/machine/lower_call.rs:68:17
[INFO] [stdout]    |
[INFO] [stdout] 68 | /                 "direct local call passes more arguments than fit in the callee local prefix"
[INFO] [stdout] 69 | |                     .into(),
[INFO] [stdout]    | |___________________________^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 68 -                 "direct local call passes more arguments than fit in the callee local prefix"
[INFO] [stdout] 69 -                     .into(),
[INFO] [stdout] 68 +                 "direct local call passes more arguments than fit in the callee local prefix",
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 68 -                 "direct local call passes more arguments than fit in the callee local prefix"
[INFO] [stdout] 69 -                     .into(),
[INFO] [stdout] 68 +                 <&str as Into<_>>::into("direct local call passes more arguments than fit in the callee local prefix"),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/vm/jit/machine/lower_call.rs:74:17
[INFO] [stdout]    |
[INFO] [stdout] 74 | /                 "direct local call result span does not match the callee return-result contract"
[INFO] [stdout] 75 | |                     .into(),
[INFO] [stdout]    | |___________________________^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 74 -                 "direct local call result span does not match the callee return-result contract"
[INFO] [stdout] 75 -                     .into(),
[INFO] [stdout] 74 +                 "direct local call result span does not match the callee return-result contract",
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 74 -                 "direct local call result span does not match the callee return-result contract"
[INFO] [stdout] 75 -                     .into(),
[INFO] [stdout] 74 +                 <&str as Into<_>>::into("direct local call result span does not match the callee return-result contract"),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/machine/lower_call.rs:164:17
[INFO] [stdout]     |
[INFO] [stdout] 164 | /                 "direct local tail call passes more arguments than fit in the callee local prefix"
[INFO] [stdout] 165 | |                     .into(),
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 164 -                 "direct local tail call passes more arguments than fit in the callee local prefix"
[INFO] [stdout] 165 -                     .into(),
[INFO] [stdout] 164 +                 "direct local tail call passes more arguments than fit in the callee local prefix",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 164 -                 "direct local tail call passes more arguments than fit in the callee local prefix"
[INFO] [stdout] 165 -                     .into(),
[INFO] [stdout] 164 +                 <&str as Into<_>>::into("direct local tail call passes more arguments than fit in the callee local prefix"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/machine/lower_call.rs:171:17
[INFO] [stdout]     |
[INFO] [stdout] 171 | /                 "direct local tail call result span does not match the callee return-result contract"
[INFO] [stdout] 172 | |                     .into(),
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 171 -                 "direct local tail call result span does not match the callee return-result contract"
[INFO] [stdout] 172 -                     .into(),
[INFO] [stdout] 171 +                 "direct local tail call result span does not match the callee return-result contract",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 171 -                 "direct local tail call result span does not match the callee return-result contract"
[INFO] [stdout] 172 -                     .into(),
[INFO] [stdout] 171 +                 <&str as Into<_>>::into("direct local tail call result span does not match the callee return-result contract"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/machine/lower_call.rs:337:17
[INFO] [stdout]     |
[INFO] [stdout] 337 |                 "live scalar call result requested for zero-result call".into(),
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 337 -                 "live scalar call result requested for zero-result call".into(),
[INFO] [stdout] 337 +                 "live scalar call result requested for zero-result call",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 337 -                 "live scalar call result requested for zero-result call".into(),
[INFO] [stdout] 337 +                 <&str as Into<_>>::into("live scalar call result requested for zero-result call"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/machine/lower_call.rs:342:17
[INFO] [stdout]     |
[INFO] [stdout] 342 |                 "live scalar call result requested for multi-result call".into(),
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 342 -                 "live scalar call result requested for multi-result call".into(),
[INFO] [stdout] 342 +                 "live scalar call result requested for multi-result call",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 342 -                 "live scalar call result requested for multi-result call".into(),
[INFO] [stdout] 342 +                 <&str as Into<_>>::into("live scalar call result requested for multi-result call"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/machine/lower_call.rs:351:25
[INFO] [stdout]     |
[INFO] [stdout] 351 |                         "live GP scalar call result type does not match callee return ABI".into(),
[INFO] [stdout]     |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 351 -                         "live GP scalar call result type does not match callee return ABI".into(),
[INFO] [stdout] 351 +                         "live GP scalar call result type does not match callee return ABI",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 351 -                         "live GP scalar call result type does not match callee return ABI".into(),
[INFO] [stdout] 351 +                         <&str as Into<_>>::into("live GP scalar call result type does not match callee return ABI"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/machine/lower_call.rs:368:25
[INFO] [stdout]     |
[INFO] [stdout] 368 |                         "live GP-pair call result type does not match callee return ABI".into(),
[INFO] [stdout]     |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 368 -                         "live GP-pair call result type does not match callee return ABI".into(),
[INFO] [stdout] 368 +                         "live GP-pair call result type does not match callee return ABI",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 368 -                         "live GP-pair call result type does not match callee return ABI".into(),
[INFO] [stdout] 368 +                         <&str as Into<_>>::into("live GP-pair call result type does not match callee return ABI"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/machine/lower_call.rs:388:25
[INFO] [stdout]     |
[INFO] [stdout] 388 |                         "live FP scalar call result type does not match callee return ABI".into(),
[INFO] [stdout]     |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 388 -                         "live FP scalar call result type does not match callee return ABI".into(),
[INFO] [stdout] 388 +                         "live FP scalar call result type does not match callee return ABI",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 388 -                         "live FP scalar call result type does not match callee return ABI".into(),
[INFO] [stdout] 388 +                         <&str as Into<_>>::into("live FP scalar call result type does not match callee return ABI"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/machine/lower_call.rs:402:37
[INFO] [stdout]     |
[INFO] [stdout] 402 |                 WasmError::internal("live scalar call result requires a scalar return ABI".into()),
[INFO] [stdout]     |                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 402 -                 WasmError::internal("live scalar call result requires a scalar return ABI".into()),
[INFO] [stdout] 402 +                 WasmError::internal("live scalar call result requires a scalar return ABI"),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 402 -                 WasmError::internal("live scalar call result requires a scalar return ABI".into()),
[INFO] [stdout] 402 +                 WasmError::internal(<&str as Into<_>>::into("live scalar call result requires a scalar return ABI")),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/machine/lower_call.rs:426:17
[INFO] [stdout]     |
[INFO] [stdout] 426 |                 "runtime call scalar result cannot materialize v128 through scalar ABI".into(),
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 426 -                 "runtime call scalar result cannot materialize v128 through scalar ABI".into(),
[INFO] [stdout] 426 +                 "runtime call scalar result cannot materialize v128 through scalar ABI",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 426 -                 "runtime call scalar result cannot materialize v128 through scalar ABI".into(),
[INFO] [stdout] 426 +                 <&str as Into<_>>::into("runtime call scalar result cannot materialize v128 through scalar ABI"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Vec<u8>`
[INFO] [stdout]   --> src/vm/jit/machine/lower_const_pool.rs:57:30
[INFO] [stdout]    |
[INFO] [stdout] 57 |     (align_of::<T>() as u32, bytes.to_vec().into())
[INFO] [stdout]    |                              ^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 57 -     (align_of::<T>() as u32, bytes.to_vec().into())
[INFO] [stdout] 57 +     (align_of::<T>() as u32, bytes.to_vec())
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 57 -     (align_of::<T>() as u32, bytes.to_vec().into())
[INFO] [stdout] 57 +     (align_of::<T>() as u32, <Vec<u8> as Into<_>>::into(bytes.to_vec()))
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Vec<CachedCell>`
[INFO] [stdout]    --> src/vm/jit/machine/lower_context.rs:292:27
[INFO] [stdout]     |
[INFO] [stdout] 292 |             cached_cells: cached_cells.to_vec().into(),
[INFO] [stdout]     |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 292 -             cached_cells: cached_cells.to_vec().into(),
[INFO] [stdout] 292 +             cached_cells: cached_cells.to_vec(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 292 -             cached_cells: cached_cells.to_vec().into(),
[INFO] [stdout] 292 +             cached_cells: <Vec<CachedCell> as Into<_>>::into(cached_cells.to_vec()),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/vm/jit/machine/lower_context.rs:1034:25
[INFO] [stdout]      |
[INFO] [stdout] 1034 |                         "linear-value budget exhausted during cache alias materialization".into(),
[INFO] [stdout]      |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1034 -                         "linear-value budget exhausted during cache alias materialization".into(),
[INFO] [stdout] 1034 +                         "linear-value budget exhausted during cache alias materialization",
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1034 -                         "linear-value budget exhausted during cache alias materialization".into(),
[INFO] [stdout] 1034 +                         <&str as Into<_>>::into("linear-value budget exhausted during cache alias materialization"),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/vm/jit/machine/lower_inst.rs:80:25
[INFO] [stdout]    |
[INFO] [stdout] 80 | ...   "SSA-IR return reached native lowering with live linear SSA values; results must be published before return".into(),
[INFO] [stdout]    |       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 80 -                         "SSA-IR return reached native lowering with live linear SSA values; results must be published before return".into(),
[INFO] [stdout] 80 +                         "SSA-IR return reached native lowering with live linear SSA values; results must be published before return",
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 80 -                         "SSA-IR return reached native lowering with live linear SSA values; results must be published before return".into(),
[INFO] [stdout] 80 +                         <&str as Into<_>>::into("SSA-IR return reached native lowering with live linear SSA values; results must be published before return"),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/machine/lower_inst.rs:149:17
[INFO] [stdout]     |
[INFO] [stdout] 149 |                 "v128 scalar return reached machine lowering".into(),
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 149 -                 "v128 scalar return reached machine lowering".into(),
[INFO] [stdout] 149 +                 "v128 scalar return reached machine lowering",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 149 -                 "v128 scalar return reached machine lowering".into(),
[INFO] [stdout] 149 +                 <&str as Into<_>>::into("v128 scalar return reached machine lowering"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/machine/lower_inst.rs:241:29
[INFO] [stdout]     |
[INFO] [stdout] 241 | ...                   "stack-resident FP scalar return reached frame fallback".into(),
[INFO] [stdout]     |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 241 -                             "stack-resident FP scalar return reached frame fallback".into(),
[INFO] [stdout] 241 +                             "stack-resident FP scalar return reached frame fallback",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 241 -                             "stack-resident FP scalar return reached frame fallback".into(),
[INFO] [stdout] 241 +                             <&str as Into<_>>::into("stack-resident FP scalar return reached frame fallback"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/vm/jit/machine/lower_inst.rs:1725:25
[INFO] [stdout]      |
[INFO] [stdout] 1725 | /                         "missing SSA-IR edge binding for target param during native lowering"
[INFO] [stdout] 1726 | |                             .into(),
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1725 -                         "missing SSA-IR edge binding for target param during native lowering"
[INFO] [stdout] 1726 -                             .into(),
[INFO] [stdout] 1725 +                         "missing SSA-IR edge binding for target param during native lowering",
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1725 -                         "missing SSA-IR edge binding for target param during native lowering"
[INFO] [stdout] 1726 -                             .into(),
[INFO] [stdout] 1725 +                         <&str as Into<_>>::into("missing SSA-IR edge binding for target param during native lowering"),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/vm/jit/machine/lower_leaf_special.rs:2809:17
[INFO] [stdout]      |
[INFO] [stdout] 2809 |                 "unexpected SIMD memory opcode in native lowering".into(),
[INFO] [stdout]      |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2809 -                 "unexpected SIMD memory opcode in native lowering".into(),
[INFO] [stdout] 2809 +                 "unexpected SIMD memory opcode in native lowering",
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2809 -                 "unexpected SIMD memory opcode in native lowering".into(),
[INFO] [stdout] 2809 +                 <&str as Into<_>>::into("unexpected SIMD memory opcode in native lowering"),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/vm/jit/machine/lower_leaf_special.rs:2827:17
[INFO] [stdout]      |
[INFO] [stdout] 2827 |                 "unexpected SIMD lane memory opcode in native lowering".into(),
[INFO] [stdout]      |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2827 -                 "unexpected SIMD lane memory opcode in native lowering".into(),
[INFO] [stdout] 2827 +                 "unexpected SIMD lane memory opcode in native lowering",
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2827 -                 "unexpected SIMD lane memory opcode in native lowering".into(),
[INFO] [stdout] 2827 +                 <&str as Into<_>>::into("unexpected SIMD lane memory opcode in native lowering"),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/vm/jit/machine/lower_module.rs:1165:21
[INFO] [stdout]      |
[INFO] [stdout] 1165 |                     "prepared SSA-IR uses inconsistent return result spans across blocks".into(),
[INFO] [stdout]      |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1165 -                     "prepared SSA-IR uses inconsistent return result spans across blocks".into(),
[INFO] [stdout] 1165 +                     "prepared SSA-IR uses inconsistent return result spans across blocks",
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1165 -                     "prepared SSA-IR uses inconsistent return result spans across blocks".into(),
[INFO] [stdout] 1165 +                     <&str as Into<_>>::into("prepared SSA-IR uses inconsistent return result spans across blocks"),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/vm/jit/machine/lower_module.rs:2420:17
[INFO] [stdout]      |
[INFO] [stdout] 2420 |                 "machine continuation blocks must be appended in id order".into(),
[INFO] [stdout]      |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2420 -                 "machine continuation blocks must be appended in id order".into(),
[INFO] [stdout] 2420 +                 "machine continuation blocks must be appended in id order",
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2420 -                 "machine continuation blocks must be appended in id order".into(),
[INFO] [stdout] 2420 +                 <&str as Into<_>>::into("machine continuation blocks must be appended in id order"),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/vm/jit/machine/lower_module.rs:2465:13
[INFO] [stdout]      |
[INFO] [stdout] 2465 |             "split continuation terminator does not branch to the continuation block".into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2465 -             "split continuation terminator does not branch to the continuation block".into(),
[INFO] [stdout] 2465 +             "split continuation terminator does not branch to the continuation block",
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2465 -             "split continuation terminator does not branch to the continuation block".into(),
[INFO] [stdout] 2465 +             <&str as Into<_>>::into("split continuation terminator does not branch to the continuation block"),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/vm/jit/machine/lower_module.rs:2594:17
[INFO] [stdout]      |
[INFO] [stdout] 2594 |                 "machine lowering emitted original blocks out of id order".into(),
[INFO] [stdout]      |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2594 -                 "machine lowering emitted original blocks out of id order".into(),
[INFO] [stdout] 2594 +                 "machine lowering emitted original blocks out of id order",
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2594 -                 "machine lowering emitted original blocks out of id order".into(),
[INFO] [stdout] 2594 +                 <&str as Into<_>>::into("machine lowering emitted original blocks out of id order"),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/vm/jit/machine/lower_module.rs:2605:17
[INFO] [stdout]      |
[INFO] [stdout] 2605 |                 "machine lowering did not produce every original block".into(),
[INFO] [stdout]      |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2605 -                 "machine lowering did not produce every original block".into(),
[INFO] [stdout] 2605 +                 "machine lowering did not produce every original block",
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2605 -                 "machine lowering did not produce every original block".into(),
[INFO] [stdout] 2605 +                 <&str as Into<_>>::into("machine lowering did not produce every original block"),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/vm/jit/machine/lower_regalloc.rs:60:17
[INFO] [stdout]    |
[INFO] [stdout] 60 |                 "native lowering requires at least one GP dynamic register".into(),
[INFO] [stdout]    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 60 -                 "native lowering requires at least one GP dynamic register".into(),
[INFO] [stdout] 60 +                 "native lowering requires at least one GP dynamic register",
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 60 -                 "native lowering requires at least one GP dynamic register".into(),
[INFO] [stdout] 60 +                 <&str as Into<_>>::into("native lowering requires at least one GP dynamic register"),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/machine/lower_regalloc.rs:317:25
[INFO] [stdout]     |
[INFO] [stdout] 317 | /                         "dynamic register budget exhausted while materializing constant operand"
[INFO] [stdout] 318 | |                             .into(),
[INFO] [stdout]     | |___________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 317 -                         "dynamic register budget exhausted while materializing constant operand"
[INFO] [stdout] 318 -                             .into(),
[INFO] [stdout] 317 +                         "dynamic register budget exhausted while materializing constant operand",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 317 -                         "dynamic register budget exhausted while materializing constant operand"
[INFO] [stdout] 318 -                             .into(),
[INFO] [stdout] 317 +                         <&str as Into<_>>::into("dynamic register budget exhausted while materializing constant operand"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/machine/lower_regalloc.rs:703:13
[INFO] [stdout]     |
[INFO] [stdout] 703 |             "machine register is not in the dynamic bank".into(),
[INFO] [stdout]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 703 -             "machine register is not in the dynamic bank".into(),
[INFO] [stdout] 703 +             "machine register is not in the dynamic bank",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 703 -             "machine register is not in the dynamic bank".into(),
[INFO] [stdout] 703 +             <&str as Into<_>>::into("machine register is not in the dynamic bank"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/machine/lower_regalloc.rs:863:13
[INFO] [stdout]     |
[INFO] [stdout] 863 |             "non-dynamic register cannot have a dynamic owner".into(),
[INFO] [stdout]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 863 -             "non-dynamic register cannot have a dynamic owner".into(),
[INFO] [stdout] 863 +             "non-dynamic register cannot have a dynamic owner",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 863 -             "non-dynamic register cannot have a dynamic owner".into(),
[INFO] [stdout] 863 +             <&str as Into<_>>::into("non-dynamic register cannot have a dynamic owner"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/vm/jit/machine/lower_simd.rs:19:17
[INFO] [stdout]    |
[INFO] [stdout] 19 |                 "SIMD lowering requires a 64-bit raw-handle ABI".into(),
[INFO] [stdout]    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 19 -                 "SIMD lowering requires a 64-bit raw-handle ABI".into(),
[INFO] [stdout] 19 +                 "SIMD lowering requires a 64-bit raw-handle ABI",
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 19 -                 "SIMD lowering requires a 64-bit raw-handle ABI".into(),
[INFO] [stdout] 19 +                 <&str as Into<_>>::into("SIMD lowering requires a 64-bit raw-handle ABI"),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/machine/lower_util.rs:224:13
[INFO] [stdout]     |
[INFO] [stdout] 224 |             "machine lowering expected exactly one result".into(),
[INFO] [stdout]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 224 -             "machine lowering expected exactly one result".into(),
[INFO] [stdout] 224 +             "machine lowering expected exactly one result",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 224 -             "machine lowering expected exactly one result".into(),
[INFO] [stdout] 224 +             <&str as Into<_>>::into("machine lowering expected exactly one result"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/machine/lower_util.rs:233:13
[INFO] [stdout]     |
[INFO] [stdout] 233 |             "machine lowering expected exactly one argument".into(),
[INFO] [stdout]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 233 -             "machine lowering expected exactly one argument".into(),
[INFO] [stdout] 233 +             "machine lowering expected exactly one argument",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 233 -             "machine lowering expected exactly one argument".into(),
[INFO] [stdout] 233 +             <&str as Into<_>>::into("machine lowering expected exactly one argument"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/machine/lower_util.rs:242:13
[INFO] [stdout]     |
[INFO] [stdout] 242 |             "machine lowering expected exactly two arguments".into(),
[INFO] [stdout]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 242 -             "machine lowering expected exactly two arguments".into(),
[INFO] [stdout] 242 +             "machine lowering expected exactly two arguments",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 242 -             "machine lowering expected exactly two arguments".into(),
[INFO] [stdout] 242 +             <&str as Into<_>>::into("machine lowering expected exactly two arguments"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/machine/lower_util.rs:253:13
[INFO] [stdout]     |
[INFO] [stdout] 253 |             "machine lowering expected exactly three arguments".into(),
[INFO] [stdout]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 253 -             "machine lowering expected exactly three arguments".into(),
[INFO] [stdout] 253 +             "machine lowering expected exactly three arguments",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 253 -             "machine lowering expected exactly three arguments".into(),
[INFO] [stdout] 253 +             <&str as Into<_>>::into("machine lowering expected exactly three arguments"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/machine/lower_util.rs:264:13
[INFO] [stdout]     |
[INFO] [stdout] 264 |             "machine lowering expected exactly four arguments".into(),
[INFO] [stdout]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 264 -             "machine lowering expected exactly four arguments".into(),
[INFO] [stdout] 264 +             "machine lowering expected exactly four arguments",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 264 -             "machine lowering expected exactly four arguments".into(),
[INFO] [stdout] 264 +             <&str as Into<_>>::into("machine lowering expected exactly four arguments"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/machine/lower_util.rs:275:13
[INFO] [stdout]     |
[INFO] [stdout] 275 |             "machine lowering expected exactly five arguments".into(),
[INFO] [stdout]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 275 -             "machine lowering expected exactly five arguments".into(),
[INFO] [stdout] 275 +             "machine lowering expected exactly five arguments",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 275 -             "machine lowering expected exactly five arguments".into(),
[INFO] [stdout] 275 +             <&str as Into<_>>::into("machine lowering expected exactly five arguments"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/vm/jit/machine/validate.rs:62:21
[INFO] [stdout]    |
[INFO] [stdout] 62 |                     "empty machine program must use entry block 0".into(),
[INFO] [stdout]    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 62 -                     "empty machine program must use entry block 0".into(),
[INFO] [stdout] 62 +                     "empty machine program must use entry block 0",
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 62 -                     "empty machine program must use entry block 0".into(),
[INFO] [stdout] 62 +                     <&str as Into<_>>::into("empty machine program must use entry block 0"),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/machine/validate.rs:338:25
[INFO] [stdout]     |
[INFO] [stdout] 338 |                         "machine Int64PairBinary requires a supported i64 binary op".into(),
[INFO] [stdout]     |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 338 -                         "machine Int64PairBinary requires a supported i64 binary op".into(),
[INFO] [stdout] 338 +                         "machine Int64PairBinary requires a supported i64 binary op",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 338 -                         "machine Int64PairBinary requires a supported i64 binary op".into(),
[INFO] [stdout] 338 +                         <&str as Into<_>>::into("machine Int64PairBinary requires a supported i64 binary op"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/machine/validate.rs:343:25
[INFO] [stdout]     |
[INFO] [stdout] 343 |                         "machine Int64PairBinary requires distinct low/high destinations".into(),
[INFO] [stdout]     |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 343 -                         "machine Int64PairBinary requires distinct low/high destinations".into(),
[INFO] [stdout] 343 +                         "machine Int64PairBinary requires distinct low/high destinations",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 343 -                         "machine Int64PairBinary requires distinct low/high destinations".into(),
[INFO] [stdout] 343 +                         <&str as Into<_>>::into("machine Int64PairBinary requires distinct low/high destinations"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/machine/validate.rs:361:25
[INFO] [stdout]     |
[INFO] [stdout] 361 | /                         "machine Int64MulFromSignExt32 requires distinct low/high destinations"
[INFO] [stdout] 362 | |                             .into(),
[INFO] [stdout]     | |___________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 361 -                         "machine Int64MulFromSignExt32 requires distinct low/high destinations"
[INFO] [stdout] 362 -                             .into(),
[INFO] [stdout] 361 +                         "machine Int64MulFromSignExt32 requires distinct low/high destinations",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 361 -                         "machine Int64MulFromSignExt32 requires distinct low/high destinations"
[INFO] [stdout] 362 -                             .into(),
[INFO] [stdout] 361 +                         <&str as Into<_>>::into("machine Int64MulFromSignExt32 requires distinct low/high destinations"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/machine/validate.rs:385:25
[INFO] [stdout]     |
[INFO] [stdout] 385 |                         "machine Int64PairDivRem requires distinct low/high destinations".into(),
[INFO] [stdout]     |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 385 -                         "machine Int64PairDivRem requires distinct low/high destinations".into(),
[INFO] [stdout] 385 +                         "machine Int64PairDivRem requires distinct low/high destinations",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 385 -                         "machine Int64PairDivRem requires distinct low/high destinations".into(),
[INFO] [stdout] 385 +                         <&str as Into<_>>::into("machine Int64PairDivRem requires distinct low/high destinations"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/machine/validate.rs:412:25
[INFO] [stdout]     |
[INFO] [stdout] 412 |                         "machine Int64PairUnary requires a supported i64 unary op".into(),
[INFO] [stdout]     |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 412 -                         "machine Int64PairUnary requires a supported i64 unary op".into(),
[INFO] [stdout] 412 +                         "machine Int64PairUnary requires a supported i64 unary op",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 412 -                         "machine Int64PairUnary requires a supported i64 unary op".into(),
[INFO] [stdout] 412 +                         <&str as Into<_>>::into("machine Int64PairUnary requires a supported i64 unary op"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/machine/validate.rs:417:25
[INFO] [stdout]     |
[INFO] [stdout] 417 |                         "machine Int64PairUnary requires distinct low/high destinations".into(),
[INFO] [stdout]     |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 417 -                         "machine Int64PairUnary requires distinct low/high destinations".into(),
[INFO] [stdout] 417 +                         "machine Int64PairUnary requires distinct low/high destinations",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 417 -                         "machine Int64PairUnary requires distinct low/high destinations".into(),
[INFO] [stdout] 417 +                         <&str as Into<_>>::into("machine Int64PairUnary requires distinct low/high destinations"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/machine/validate.rs:445:25
[INFO] [stdout]     |
[INFO] [stdout] 445 |                         "machine Int64PairShift requires a shift/rotate op".into(),
[INFO] [stdout]     |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 445 -                         "machine Int64PairShift requires a shift/rotate op".into(),
[INFO] [stdout] 445 +                         "machine Int64PairShift requires a shift/rotate op",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 445 -                         "machine Int64PairShift requires a shift/rotate op".into(),
[INFO] [stdout] 445 +                         <&str as Into<_>>::into("machine Int64PairShift requires a shift/rotate op"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/machine/validate.rs:450:25
[INFO] [stdout]     |
[INFO] [stdout] 450 |                         "machine Int64PairShift requires distinct low/high destinations".into(),
[INFO] [stdout]     |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 450 -                         "machine Int64PairShift requires distinct low/high destinations".into(),
[INFO] [stdout] 450 +                         "machine Int64PairShift requires distinct low/high destinations",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 450 -                         "machine Int64PairShift requires distinct low/high destinations".into(),
[INFO] [stdout] 450 +                         <&str as Into<_>>::into("machine Int64PairShift requires distinct low/high destinations"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/machine/validate.rs:516:25
[INFO] [stdout]     |
[INFO] [stdout] 516 |                         "machine ConvertFloatToI64Pair requires an i64 trunc/trunc_sat op".into(),
[INFO] [stdout]     |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 516 -                         "machine ConvertFloatToI64Pair requires an i64 trunc/trunc_sat op".into(),
[INFO] [stdout] 516 +                         "machine ConvertFloatToI64Pair requires an i64 trunc/trunc_sat op",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 516 -                         "machine ConvertFloatToI64Pair requires an i64 trunc/trunc_sat op".into(),
[INFO] [stdout] 516 +                         <&str as Into<_>>::into("machine ConvertFloatToI64Pair requires an i64 trunc/trunc_sat op"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/machine/validate.rs:534:25
[INFO] [stdout]     |
[INFO] [stdout] 534 | /                         "machine ConvertFloatToI64Pair requires distinct low/high destinations"
[INFO] [stdout] 535 | |                             .into(),
[INFO] [stdout]     | |___________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 534 -                         "machine ConvertFloatToI64Pair requires distinct low/high destinations"
[INFO] [stdout] 535 -                             .into(),
[INFO] [stdout] 534 +                         "machine ConvertFloatToI64Pair requires distinct low/high destinations",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 534 -                         "machine ConvertFloatToI64Pair requires distinct low/high destinations"
[INFO] [stdout] 535 -                             .into(),
[INFO] [stdout] 534 +                         <&str as Into<_>>::into("machine ConvertFloatToI64Pair requires distinct low/high destinations"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/machine/validate.rs:554:25
[INFO] [stdout]     |
[INFO] [stdout] 554 | /                         "machine ReinterpretF64ToI64Pair requires distinct low/high destinations"
[INFO] [stdout] 555 | |                             .into(),
[INFO] [stdout]     | |___________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 554 -                         "machine ReinterpretF64ToI64Pair requires distinct low/high destinations"
[INFO] [stdout] 555 -                             .into(),
[INFO] [stdout] 554 +                         "machine ReinterpretF64ToI64Pair requires distinct low/high destinations",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 554 -                         "machine ReinterpretF64ToI64Pair requires distinct low/high destinations"
[INFO] [stdout] 555 -                             .into(),
[INFO] [stdout] 554 +                         <&str as Into<_>>::into("machine ReinterpretF64ToI64Pair requires distinct low/high destinations"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/vm/jit/middle/ssa_ir/validate.rs:26:17
[INFO] [stdout]    |
[INFO] [stdout] 26 |                 "empty SSA-IR program must use entry block 0".into(),
[INFO] [stdout]    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 26 -                 "empty SSA-IR program must use entry block 0".into(),
[INFO] [stdout] 26 +                 "empty SSA-IR program must use entry block 0",
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 26 -                 "empty SSA-IR program must use entry block 0".into(),
[INFO] [stdout] 26 +                 <&str as Into<_>>::into("empty SSA-IR program must use entry block 0"),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Vec<value_type::ValueType>`
[INFO] [stdout]    --> src/vm/jit/middle/joint_plan/build.rs:214:13
[INFO] [stdout]     |
[INFO] [stdout] 214 |             self.type_stack[start..end].to_vec().into()
[INFO] [stdout]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 214 -             self.type_stack[start..end].to_vec().into()
[INFO] [stdout] 214 +             self.type_stack[start..end].to_vec()
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 214 -             self.type_stack[start..end].to_vec().into()
[INFO] [stdout] 214 +             <Vec<value_type::ValueType> as Into<_>>::into(self.type_stack[start..end].to_vec())
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Vec<value_type::ValueType>`
[INFO] [stdout]    --> src/vm/jit/middle/joint_plan/build.rs:550:20
[INFO] [stdout]     |
[INFO] [stdout] 550 |             return types.to_vec().into();
[INFO] [stdout]     |                    ^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 550 -             return types.to_vec().into();
[INFO] [stdout] 550 +             return types.to_vec();
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 550 -             return types.to_vec().into();
[INFO] [stdout] 550 +             return <Vec<value_type::ValueType> as Into<_>>::into(types.to_vec());
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Vec<bool>`
[INFO] [stdout]    --> src/vm/jit/middle/joint_plan/init_locals.rs:261:19
[INFO] [stdout]     |
[INFO] [stdout] 261 |             out = path.to_vec().into();
[INFO] [stdout]     |                   ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 261 -             out = path.to_vec().into();
[INFO] [stdout] 261 +             out = path.to_vec();
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 261 -             out = path.to_vec().into();
[INFO] [stdout] 261 +             out = <Vec<bool> as Into<_>>::into(path.to_vec());
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Vec<bool>`
[INFO] [stdout]    --> src/vm/jit/middle/joint_plan/init_locals.rs:275:46
[INFO] [stdout]     |
[INFO] [stdout] 275 |         (Some(a), None) | (None, Some(a)) => a.to_vec().into(),
[INFO] [stdout]     |                                              ^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 275 -         (Some(a), None) | (None, Some(a)) => a.to_vec().into(),
[INFO] [stdout] 275 +         (Some(a), None) | (None, Some(a)) => a.to_vec(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 275 -         (Some(a), None) | (None, Some(a)) => a.to_vec().into(),
[INFO] [stdout] 275 +         (Some(a), None) | (None, Some(a)) => <Vec<bool> as Into<_>>::into(a.to_vec()),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Vec<CellId>`
[INFO] [stdout]    --> src/vm/jit/middle/rewrite/edge.rs:176:38
[INFO] [stdout]     |
[INFO] [stdout] 176 |                 ensure_cached_cells: plan.slot_arena[spans.ensure.range()].to_vec().into(),
[INFO] [stdout]     |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 176 -                 ensure_cached_cells: plan.slot_arena[spans.ensure.range()].to_vec().into(),
[INFO] [stdout] 176 +                 ensure_cached_cells: plan.slot_arena[spans.ensure.range()].to_vec(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 176 -                 ensure_cached_cells: plan.slot_arena[spans.ensure.range()].to_vec().into(),
[INFO] [stdout] 176 +                 ensure_cached_cells: <Vec<CellId> as Into<_>>::into(plan.slot_arena[spans.ensure.range()].to_vec()),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Vec<CellId>`
[INFO] [stdout]    --> src/vm/jit/middle/rewrite/edge.rs:177:39
[INFO] [stdout]     |
[INFO] [stdout] 177 |                 reserve_cached_cells: plan.slot_arena[spans.reserve.range()].to_vec().into(),
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 177 -                 reserve_cached_cells: plan.slot_arena[spans.reserve.range()].to_vec().into(),
[INFO] [stdout] 177 +                 reserve_cached_cells: plan.slot_arena[spans.reserve.range()].to_vec(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 177 -                 reserve_cached_cells: plan.slot_arena[spans.reserve.range()].to_vec().into(),
[INFO] [stdout] 177 +                 reserve_cached_cells: <Vec<CellId> as Into<_>>::into(plan.slot_arena[spans.reserve.range()].to_vec()),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Vec<CellId>`
[INFO] [stdout]    --> src/vm/jit/middle/rewrite/edge.rs:178:36
[INFO] [stdout]     |
[INFO] [stdout] 178 |                 drop_cached_cells: plan.slot_arena[spans.drop.range()].to_vec().into(),
[INFO] [stdout]     |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 178 -                 drop_cached_cells: plan.slot_arena[spans.drop.range()].to_vec().into(),
[INFO] [stdout] 178 +                 drop_cached_cells: plan.slot_arena[spans.drop.range()].to_vec(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 178 -                 drop_cached_cells: plan.slot_arena[spans.drop.range()].to_vec().into(),
[INFO] [stdout] 178 +                 drop_cached_cells: <Vec<CellId> as Into<_>>::into(plan.slot_arena[spans.drop.range()].to_vec()),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Vec<CellId>`
[INFO] [stdout]    --> src/vm/jit/middle/rewrite/edge.rs:294:20
[INFO] [stdout]     |
[INFO] [stdout] 294 |         pred_exit: pred_exit.to_vec().into(),
[INFO] [stdout]     |                    ^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 294 -         pred_exit: pred_exit.to_vec().into(),
[INFO] [stdout] 294 +         pred_exit: pred_exit.to_vec(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 294 -         pred_exit: pred_exit.to_vec().into(),
[INFO] [stdout] 294 +         pred_exit: <Vec<CellId> as Into<_>>::into(pred_exit.to_vec()),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Vec<CellId>`
[INFO] [stdout]    --> src/vm/jit/middle/rewrite/edge.rs:323:15
[INFO] [stdout]     |
[INFO] [stdout] 323 |         .push(pred_exit.to_vec().into());
[INFO] [stdout]     |               ^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 323 -         .push(pred_exit.to_vec().into());
[INFO] [stdout] 323 +         .push(pred_exit.to_vec());
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 323 -         .push(pred_exit.to_vec().into());
[INFO] [stdout] 323 +         .push(<Vec<CellId> as Into<_>>::into(pred_exit.to_vec()));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/middle/rewrite/function.rs:855:13
[INFO] [stdout]     |
[INFO] [stdout] 855 |             "control/return op must be block terminator".into(),
[INFO] [stdout]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 855 -             "control/return op must be block terminator".into(),
[INFO] [stdout] 855 +             "control/return op must be block terminator",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 855 -             "control/return op must be block terminator".into(),
[INFO] [stdout] 855 +             <&str as Into<_>>::into("control/return op must be block terminator"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Vec<value_type::ValueType>`
[INFO] [stdout]     --> src/vm/jit/middle/rewrite/function.rs:1084:23
[INFO] [stdout]      |
[INFO] [stdout] 1084 |         result_types: result_types.to_vec().into(),
[INFO] [stdout]      |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1084 -         result_types: result_types.to_vec().into(),
[INFO] [stdout] 1084 +         result_types: result_types.to_vec(),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1084 -         result_types: result_types.to_vec().into(),
[INFO] [stdout] 1084 +         result_types: <Vec<value_type::ValueType> as Into<_>>::into(result_types.to_vec()),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Vec<value_type::ValueType>`
[INFO] [stdout]     --> src/vm/jit/middle/rewrite/function.rs:1138:23
[INFO] [stdout]      |
[INFO] [stdout] 1138 |         result_types: result_types.to_vec().into(),
[INFO] [stdout]      |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1138 -         result_types: result_types.to_vec().into(),
[INFO] [stdout] 1138 +         result_types: result_types.to_vec(),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1138 -         result_types: result_types.to_vec().into(),
[INFO] [stdout] 1138 +         result_types: <Vec<value_type::ValueType> as Into<_>>::into(result_types.to_vec()),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Vec<value_type::ValueType>`
[INFO] [stdout]     --> src/vm/jit/middle/rewrite/function.rs:1183:23
[INFO] [stdout]      |
[INFO] [stdout] 1183 |         result_types: result_types.to_vec().into(),
[INFO] [stdout]      |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1183 -         result_types: result_types.to_vec().into(),
[INFO] [stdout] 1183 +         result_types: result_types.to_vec(),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1183 -         result_types: result_types.to_vec().into(),
[INFO] [stdout] 1183 +         result_types: <Vec<value_type::ValueType> as Into<_>>::into(result_types.to_vec()),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/vm/jit/middle/rewrite/function.rs:1394:13
[INFO] [stdout]      |
[INFO] [stdout] 1394 |             "br_on_cast target type must be a reference".into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1394 -             "br_on_cast target type must be a reference".into(),
[INFO] [stdout] 1394 +             "br_on_cast target type must be a reference",
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1394 -             "br_on_cast target type must be a reference".into(),
[INFO] [stdout] 1394 +             <&str as Into<_>>::into("br_on_cast target type must be a reference"),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/vm/jit/middle/rewrite/function.rs:1824:29
[INFO] [stdout]      |
[INFO] [stdout] 1824 | ...                   "taken br_if with payload must have payload span".into(),
[INFO] [stdout]      |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1824 -                             "taken br_if with payload must have payload span".into(),
[INFO] [stdout] 1824 +                             "taken br_if with payload must have payload span",
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1824 -                             "taken br_if with payload must have payload span".into(),
[INFO] [stdout] 1824 +                             <&str as Into<_>>::into("taken br_if with payload must have payload span"),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/vm/jit/middle/rewrite/function.rs:1833:25
[INFO] [stdout]      |
[INFO] [stdout] 1833 |                         "synthetic br_if then bridge requires canonical-only branch target".into(),
[INFO] [stdout]      |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1833 -                         "synthetic br_if then bridge requires canonical-only branch target".into(),
[INFO] [stdout] 1833 +                         "synthetic br_if then bridge requires canonical-only branch target",
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1833 -                         "synthetic br_if then bridge requires canonical-only branch target".into(),
[INFO] [stdout] 1833 +                         <&str as Into<_>>::into("synthetic br_if then bridge requires canonical-only branch target"),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/vm/jit/middle/rewrite/function.rs:2555:25
[INFO] [stdout]      |
[INFO] [stdout] 2555 |                         "taken branch target expects no live values but still has params".into(),
[INFO] [stdout]      |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2555 -                         "taken branch target expects no live values but still has params".into(),
[INFO] [stdout] 2555 +                         "taken branch target expects no live values but still has params",
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2555 -                         "taken branch target expects no live values but still has params".into(),
[INFO] [stdout] 2555 +                         <&str as Into<_>>::into("taken branch target expects no live values but still has params"),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/vm/jit/middle/rewrite/function.rs:2564:25
[INFO] [stdout]      |
[INFO] [stdout] 2564 |                         "taken branch payload width mismatch".into(),
[INFO] [stdout]      |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2564 -                         "taken branch payload width mismatch".into(),
[INFO] [stdout] 2564 +                         "taken branch payload width mismatch",
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2564 -                         "taken branch payload width mismatch".into(),
[INFO] [stdout] 2564 +                         <&str as Into<_>>::into("taken branch payload width mismatch"),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/vm/jit/middle/rewrite/function.rs:2593:44
[INFO] [stdout]      |
[INFO] [stdout] 2593 |         .ok_or_else(|| WasmError::internal("edge binding underflow".into()))?;
[INFO] [stdout]      |                                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2593 -         .ok_or_else(|| WasmError::internal("edge binding underflow".into()))?;
[INFO] [stdout] 2593 +         .ok_or_else(|| WasmError::internal("edge binding underflow"))?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2593 -         .ok_or_else(|| WasmError::internal("edge binding underflow".into()))?;
[INFO] [stdout] 2593 +         .ok_or_else(|| WasmError::internal(<&str as Into<_>>::into("edge binding underflow")))?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/vm/jit/middle/rewrite/function.rs:2616:21
[INFO] [stdout]      |
[INFO] [stdout] 2616 |                     "edge binding type refinement requires ref-compatible value".into(),
[INFO] [stdout]      |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2616 -                     "edge binding type refinement requires ref-compatible value".into(),
[INFO] [stdout] 2616 +                     "edge binding type refinement requires ref-compatible value",
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2616 -                     "edge binding type refinement requires ref-compatible value".into(),
[INFO] [stdout] 2616 +                     <&str as Into<_>>::into("edge binding type refinement requires ref-compatible value"),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Vec<value_type::ValueType>`
[INFO] [stdout]    --> src/vm/jit/middle/rewrite/state.rs:162:13
[INFO] [stdout]     |
[INFO] [stdout] 162 |             full_stack_types.to_vec().into(),
[INFO] [stdout]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 162 -             full_stack_types.to_vec().into(),
[INFO] [stdout] 162 +             full_stack_types.to_vec(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 162 -             full_stack_types.to_vec().into(),
[INFO] [stdout] 162 +             <Vec<value_type::ValueType> as Into<_>>::into(full_stack_types.to_vec()),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Vec<value_type::ValueType>`
[INFO] [stdout]    --> src/vm/jit/middle/rewrite/state.rs:163:13
[INFO] [stdout]     |
[INFO] [stdout] 163 |             entry.live_types.to_vec().into(),
[INFO] [stdout]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 163 -             entry.live_types.to_vec().into(),
[INFO] [stdout] 163 +             entry.live_types.to_vec(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 163 -             entry.live_types.to_vec().into(),
[INFO] [stdout] 163 +             <Vec<value_type::ValueType> as Into<_>>::into(entry.live_types.to_vec()),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Vec<SsaValue>`
[INFO] [stdout]    --> src/vm/jit/middle/rewrite/state.rs:171:19
[INFO] [stdout]     |
[INFO] [stdout] 171 |             live: params.to_vec().into(),
[INFO] [stdout]     |                   ^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 171 -             live: params.to_vec().into(),
[INFO] [stdout] 171 +             live: params.to_vec(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 171 -             live: params.to_vec().into(),
[INFO] [stdout] 171 +             live: <Vec<SsaValue> as Into<_>>::into(params.to_vec()),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Vec<SsaValue>`
[INFO] [stdout]    --> src/vm/jit/middle/rewrite/state.rs:198:12
[INFO] [stdout]     |
[INFO] [stdout] 198 |         Ok(self.live[self.live.len() - count..].to_vec().into())
[INFO] [stdout]     |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 198 -         Ok(self.live[self.live.len() - count..].to_vec().into())
[INFO] [stdout] 198 +         Ok(self.live[self.live.len() - count..].to_vec())
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 198 -         Ok(self.live[self.live.len() - count..].to_vec().into())
[INFO] [stdout] 198 +         Ok(<Vec<SsaValue> as Into<_>>::into(self.live[self.live.len() - count..].to_vec()))
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/vm/jit/runtime/guard_pages.rs:61:17
[INFO] [stdout]    |
[INFO] [stdout] 61 |                 "guard-page memory: initial size exceeds reservation".into(),
[INFO] [stdout]    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 61 -                 "guard-page memory: initial size exceeds reservation".into(),
[INFO] [stdout] 61 +                 "guard-page memory: initial size exceeds reservation",
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 61 -                 "guard-page memory: initial size exceeds reservation".into(),
[INFO] [stdout] 61 +                 <&str as Into<_>>::into("guard-page memory: initial size exceeds reservation"),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/runtime/guard_pages.rs:108:17
[INFO] [stdout]     |
[INFO] [stdout] 108 |                 "guard-page memory: grow exceeds reservation".into(),
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 108 -                 "guard-page memory: grow exceeds reservation".into(),
[INFO] [stdout] 108 +                 "guard-page memory: grow exceeds reservation",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 108 -                 "guard-page memory: grow exceeds reservation".into(),
[INFO] [stdout] 108 +                 <&str as Into<_>>::into("guard-page memory: grow exceeds reservation"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Vec<value_type::ValueType>`
[INFO] [stdout]   --> src/vm/jit/wasm/context.rs:83:27
[INFO] [stdout]    |
[INFO] [stdout] 83 |                 .map(|ty| ty.results().to_vec().into())
[INFO] [stdout]    |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 83 -                 .map(|ty| ty.results().to_vec().into())
[INFO] [stdout] 83 +                 .map(|ty| ty.results().to_vec())
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 83 -                 .map(|ty| ty.results().to_vec().into())
[INFO] [stdout] 83 +                 .map(|ty| <Vec<value_type::ValueType> as Into<_>>::into(ty.results().to_vec()))
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Vec<value_type::ValueType>`
[INFO] [stdout]    --> src/vm/jit/wasm/decode.rs:503:31
[INFO] [stdout]     |
[INFO] [stdout] 503 |                 result_types: compile.result_types.to_vec().into(),
[INFO] [stdout]     |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 503 -                 result_types: compile.result_types.to_vec().into(),
[INFO] [stdout] 503 +                 result_types: compile.result_types.to_vec(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 503 -                 result_types: compile.result_types.to_vec().into(),
[INFO] [stdout] 503 +                 result_types: <Vec<value_type::ValueType> as Into<_>>::into(compile.result_types.to_vec()),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Vec<value_type::ValueType>`
[INFO] [stdout]    --> src/vm/jit/wasm/decode.rs:641:13
[INFO] [stdout]     |
[INFO] [stdout] 641 |             self.type_stack[start..end].to_vec().into()
[INFO] [stdout]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 641 -             self.type_stack[start..end].to_vec().into()
[INFO] [stdout] 641 +             self.type_stack[start..end].to_vec()
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 641 -             self.type_stack[start..end].to_vec().into()
[INFO] [stdout] 641 +             <Vec<value_type::ValueType> as Into<_>>::into(self.type_stack[start..end].to_vec())
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Vec<value_type::ValueType>`
[INFO] [stdout]    --> src/vm/jit/wasm/decode.rs:917:41
[INFO] [stdout]     |
[INFO] [stdout] 917 |                 .insert(idx.as_usize(), tys.to_vec().into());
[INFO] [stdout]     |                                         ^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 917 -                 .insert(idx.as_usize(), tys.to_vec().into());
[INFO] [stdout] 917 +                 .insert(idx.as_usize(), tys.to_vec());
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 917 -                 .insert(idx.as_usize(), tys.to_vec().into());
[INFO] [stdout] 917 +                 .insert(idx.as_usize(), <Vec<value_type::ValueType> as Into<_>>::into(tys.to_vec()));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Vec<value_type::ValueType>`
[INFO] [stdout]     --> src/vm/jit/wasm/decode.rs:1192:13
[INFO] [stdout]      |
[INFO] [stdout] 1192 |             self.compile.local_types.to_vec().into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1192 -             self.compile.local_types.to_vec().into(),
[INFO] [stdout] 1192 +             self.compile.local_types.to_vec(),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1192 -             self.compile.local_types.to_vec().into(),
[INFO] [stdout] 1192 +             <Vec<value_type::ValueType> as Into<_>>::into(self.compile.local_types.to_vec()),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Vec<value_type::ValueType>`
[INFO] [stdout]     --> src/vm/jit/wasm/decode.rs:1193:13
[INFO] [stdout]      |
[INFO] [stdout] 1193 |             self.compile.result_types.to_vec().into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1193 -             self.compile.result_types.to_vec().into(),
[INFO] [stdout] 1193 +             self.compile.result_types.to_vec(),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1193 -             self.compile.result_types.to_vec().into(),
[INFO] [stdout] 1193 +             <Vec<value_type::ValueType> as Into<_>>::into(self.compile.result_types.to_vec()),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `sf-nano-core` (lib) due to 149 previous errors
[INFO] [stderr] warning: build failed, waiting for other jobs to finish...
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/module/parser.rs:287:17
[INFO] [stdout]     |
[INFO] [stdout] 287 |                 "data count and data section have inconsistent lengths".into(),
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: `#[deny(self_type_conversion)]` on by default
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 287 -                 "data count and data section have inconsistent lengths".into(),
[INFO] [stdout] 287 +                 "data count and data section have inconsistent lengths",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 287 -                 "data count and data section have inconsistent lengths".into(),
[INFO] [stdout] 287 +                 <&str as Into<_>>::into("data count and data section have inconsistent lengths"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/module/parser.rs:518:17
[INFO] [stdout]     |
[INFO] [stdout] 518 |                 "malformed global mutable value".into(),
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 518 -                 "malformed global mutable value".into(),
[INFO] [stdout] 518 +                 "malformed global mutable value",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 518 -                 "malformed global mutable value".into(),
[INFO] [stdout] 518 +                 <&str as Into<_>>::into("malformed global mutable value"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/module/validator/expressions.rs:107:29
[INFO] [stdout]     |
[INFO] [stdout] 107 | ...                   "Invalid function index for ref.func".into(),
[INFO] [stdout]     |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 107 -                             "Invalid function index for ref.func".into(),
[INFO] [stdout] 107 +                             "Invalid function index for ref.func",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 107 -                             "Invalid function index for ref.func".into(),
[INFO] [stdout] 107 +                             <&str as Into<_>>::into("Invalid function index for ref.func"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/module/validator/expressions.rs:121:29
[INFO] [stdout]     |
[INFO] [stdout] 121 | ...                   "constant expression cannot reference mutable global".into(),
[INFO] [stdout]     |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 121 -                             "constant expression cannot reference mutable global".into(),
[INFO] [stdout] 121 +                             "constant expression cannot reference mutable global",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 121 -                             "constant expression cannot reference mutable global".into(),
[INFO] [stdout] 121 +                             <&str as Into<_>>::into("constant expression cannot reference mutable global"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/module/validator/expressions.rs:138:29
[INFO] [stdout]     |
[INFO] [stdout] 138 | ...                   "Not enough operands for binary operation".into(),
[INFO] [stdout]     |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 138 -                             "Not enough operands for binary operation".into(),
[INFO] [stdout] 138 +                             "Not enough operands for binary operation",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 138 -                             "Not enough operands for binary operation".into(),
[INFO] [stdout] 138 +                             <&str as Into<_>>::into("Not enough operands for binary operation"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/module/validator/expressions.rs:145:29
[INFO] [stdout]     |
[INFO] [stdout] 145 | ...                   "Type mismatch in i32 binary operation".into(),
[INFO] [stdout]     |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 145 -                             "Type mismatch in i32 binary operation".into(),
[INFO] [stdout] 145 +                             "Type mismatch in i32 binary operation",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 145 -                             "Type mismatch in i32 binary operation".into(),
[INFO] [stdout] 145 +                             <&str as Into<_>>::into("Type mismatch in i32 binary operation"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/module/validator/expressions.rs:153:29
[INFO] [stdout]     |
[INFO] [stdout] 153 | ...                   "Not enough operands for binary operation".into(),
[INFO] [stdout]     |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 153 -                             "Not enough operands for binary operation".into(),
[INFO] [stdout] 153 +                             "Not enough operands for binary operation",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 153 -                             "Not enough operands for binary operation".into(),
[INFO] [stdout] 153 +                             <&str as Into<_>>::into("Not enough operands for binary operation"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/module/validator/expressions.rs:160:29
[INFO] [stdout]     |
[INFO] [stdout] 160 | ...                   "Type mismatch in i64 binary operation".into(),
[INFO] [stdout]     |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 160 -                             "Type mismatch in i64 binary operation".into(),
[INFO] [stdout] 160 +                             "Type mismatch in i64 binary operation",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 160 -                             "Type mismatch in i64 binary operation".into(),
[INFO] [stdout] 160 +                             <&str as Into<_>>::into("Type mismatch in i64 binary operation"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/module/validator/expressions.rs:371:29
[INFO] [stdout]     |
[INFO] [stdout] 371 | ...                   "Invalid stack length at the end of the code".into(),
[INFO] [stdout]     |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 371 -                             "Invalid stack length at the end of the code".into(),
[INFO] [stdout] 371 +                             "Invalid stack length at the end of the code",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 371 -                             "Invalid stack length at the end of the code".into(),
[INFO] [stdout] 371 +                             <&str as Into<_>>::into("Invalid stack length at the end of the code"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/module/validator/functions.rs:670:25
[INFO] [stdout]     |
[INFO] [stdout] 670 |                         "if without else should keep the stack consistent".into(),
[INFO] [stdout]     |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 670 -                         "if without else should keep the stack consistent".into(),
[INFO] [stdout] 670 +                         "if without else should keep the stack consistent",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 670 -                         "if without else should keep the stack consistent".into(),
[INFO] [stdout] 670 +                         <&str as Into<_>>::into("if without else should keep the stack consistent"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/module/validator/functions.rs:846:25
[INFO] [stdout]     |
[INFO] [stdout] 846 |                         "SELECT requires both operands to be numbers or both be vectors".into(),
[INFO] [stdout]     |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 846 -                         "SELECT requires both operands to be numbers or both be vectors".into(),
[INFO] [stdout] 846 +                         "SELECT requires both operands to be numbers or both be vectors",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 846 -                         "SELECT requires both operands to be numbers or both be vectors".into(),
[INFO] [stdout] 846 +                         <&str as Into<_>>::into("SELECT requires both operands to be numbers or both be vectors"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/module/validator/functions.rs:1216:25
[INFO] [stdout]      |
[INFO] [stdout] 1216 |                         "invalid memory init memory index".into(),
[INFO] [stdout]      |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1216 -                         "invalid memory init memory index".into(),
[INFO] [stdout] 1216 +                         "invalid memory init memory index",
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1216 -                         "invalid memory init memory index".into(),
[INFO] [stdout] 1216 +                         <&str as Into<_>>::into("invalid memory init memory index"),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/module/validator/functions.rs:1221:25
[INFO] [stdout]      |
[INFO] [stdout] 1221 |                         "memory.init requires a datacount section".into(),
[INFO] [stdout]      |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1221 -                         "memory.init requires a datacount section".into(),
[INFO] [stdout] 1221 +                         "memory.init requires a datacount section",
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1221 -                         "memory.init requires a datacount section".into(),
[INFO] [stdout] 1221 +                         <&str as Into<_>>::into("memory.init requires a datacount section"),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/module/validator/functions.rs:1239:25
[INFO] [stdout]      |
[INFO] [stdout] 1239 |                         "invalid memory copy destination memory index".into(),
[INFO] [stdout]      |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1239 -                         "invalid memory copy destination memory index".into(),
[INFO] [stdout] 1239 +                         "invalid memory copy destination memory index",
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1239 -                         "invalid memory copy destination memory index".into(),
[INFO] [stdout] 1239 +                         <&str as Into<_>>::into("invalid memory copy destination memory index"),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/module/validator/functions.rs:1244:25
[INFO] [stdout]      |
[INFO] [stdout] 1244 |                         "invalid memory copy source memory index".into(),
[INFO] [stdout]      |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1244 -                         "invalid memory copy source memory index".into(),
[INFO] [stdout] 1244 +                         "invalid memory copy source memory index",
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1244 -                         "invalid memory copy source memory index".into(),
[INFO] [stdout] 1244 +                         <&str as Into<_>>::into("invalid memory copy source memory index"),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/module/validator/functions.rs:1264:25
[INFO] [stdout]      |
[INFO] [stdout] 1264 |                         "invalid memory fill memory index".into(),
[INFO] [stdout]      |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1264 -                         "invalid memory fill memory index".into(),
[INFO] [stdout] 1264 +                         "invalid memory fill memory index",
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1264 -                         "invalid memory fill memory index".into(),
[INFO] [stdout] 1264 +                         <&str as Into<_>>::into("invalid memory fill memory index"),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/module/validator/functions.rs:1281:25
[INFO] [stdout]      |
[INFO] [stdout] 1281 |                         "data.drop requires a datacount section".into(),
[INFO] [stdout]      |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1281 -                         "data.drop requires a datacount section".into(),
[INFO] [stdout] 1281 +                         "data.drop requires a datacount section",
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1281 -                         "data.drop requires a datacount section".into(),
[INFO] [stdout] 1281 +                         <&str as Into<_>>::into("data.drop requires a datacount section"),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/module/validator/functions.rs:1300:25
[INFO] [stdout]      |
[INFO] [stdout] 1300 |                         "invalid table init element index".into(),
[INFO] [stdout]      |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1300 -                         "invalid table init element index".into(),
[INFO] [stdout] 1300 +                         "invalid table init element index",
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1300 -                         "invalid table init element index".into(),
[INFO] [stdout] 1300 +                         <&str as Into<_>>::into("invalid table init element index"),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/module/validator/functions.rs:2471:17
[INFO] [stdout]      |
[INFO] [stdout] 2471 |                 "popping value while control frame stack is empty".into(),
[INFO] [stdout]      |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2471 -                 "popping value while control frame stack is empty".into(),
[INFO] [stdout] 2471 +                 "popping value while control frame stack is empty",
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2471 -                 "popping value while control frame stack is empty".into(),
[INFO] [stdout] 2471 +                 <&str as Into<_>>::into("popping value while control frame stack is empty"),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/module/validator/functions.rs:2547:17
[INFO] [stdout]      |
[INFO] [stdout] 2547 |                 "cannot pop from an empty control frame stack".into(),
[INFO] [stdout]      |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2547 -                 "cannot pop from an empty control frame stack".into(),
[INFO] [stdout] 2547 +                 "cannot pop from an empty control frame stack",
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2547 -                 "cannot pop from an empty control frame stack".into(),
[INFO] [stdout] 2547 +                 <&str as Into<_>>::into("cannot pop from an empty control frame stack"),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/module/validator/mod.rs:204:25
[INFO] [stdout]     |
[INFO] [stdout] 204 |                         "element offset expression must return i32".into(),
[INFO] [stdout]     |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 204 -                         "element offset expression must return i32".into(),
[INFO] [stdout] 204 +                         "element offset expression must return i32",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 204 -                         "element offset expression must return i32".into(),
[INFO] [stdout] 204 +                         <&str as Into<_>>::into("element offset expression must return i32"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `Rc<dyn Fn(&mut Caller<'a>, &[Value], &mut [Value]) -> Result<(), _>>`
[INFO] [stdout]    --> src/vm/entities.rs:100:45
[INFO] [stdout]     |
[INFO] [stdout] 100 |         let callback: Rc<DynHostCallback> = callback.into();
[INFO] [stdout]     |                                             ^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]     = note: the full name for the type has been written to '/opt/rustwide/target/debug/build/sf-nano-core/5f2c79c083eb556d/out/sf_nano_core-5f2c79c083eb556d.long-type-8073334866438496834.txt'
[INFO] [stdout]     = note: consider using `--verbose` to print the full type name to the console
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 100 -         let callback: Rc<DynHostCallback> = callback.into();
[INFO] [stdout] 100 +         let callback: Rc<DynHostCallback> = callback;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 100 -         let callback: Rc<DynHostCallback> = callback.into();
[INFO] [stdout] 100 +         let callback: Rc<DynHostCallback> = <tracked_alloc::Rc<dyn for<'b, 'a, 'c, 'd> Fn(&'b mut vm::entities::Caller<'a>, &'c [vm::value::Value], &'d mut [vm::value::Value]) -> Result<(), error::WasmError>> as Into<_>>::into(callback);
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `tracked_alloc::Rc<InstanceTableInner>`
[INFO] [stdout]    --> src/vm/link.rs:406:23
[INFO] [stdout]     |
[INFO] [stdout] 406 |         InstanceTable(table.into()).checkout(id)
[INFO] [stdout]     |                       ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 406 -         InstanceTable(table.into()).checkout(id)
[INFO] [stdout] 406 +         InstanceTable(table).checkout(id)
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 406 -         InstanceTable(table.into()).checkout(id)
[INFO] [stdout] 406 +         InstanceTable(<tracked_alloc::Rc<InstanceTableInner> as Into<_>>::into(table)).checkout(id)
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `tracked_alloc::Rc<InstanceTableInner>`
[INFO] [stdout]    --> src/vm/link.rs:418:23
[INFO] [stdout]     |
[INFO] [stdout] 418 |         InstanceTable(table.into()).checkout(id)
[INFO] [stdout]     |                       ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 418 -         InstanceTable(table.into()).checkout(id)
[INFO] [stdout] 418 +         InstanceTable(table).checkout(id)
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 418 -         InstanceTable(table.into()).checkout(id)
[INFO] [stdout] 418 +         InstanceTable(<tracked_alloc::Rc<InstanceTableInner> as Into<_>>::into(table)).checkout(id)
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `tracked_alloc::Rc<InstanceTableInner>`
[INFO] [stdout]    --> src/vm/link.rs:424:28
[INFO] [stdout]     |
[INFO] [stdout] 424 |         Some(InstanceTable(table.into()))
[INFO] [stdout]     |                            ^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 424 -         Some(InstanceTable(table.into()))
[INFO] [stdout] 424 +         Some(InstanceTable(table))
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 424 -         Some(InstanceTable(table.into()))
[INFO] [stdout] 424 +         Some(InstanceTable(<tracked_alloc::Rc<InstanceTableInner> as Into<_>>::into(table)))
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `tracked_alloc::Vec<machine_ir::types::MachineValue>`
[INFO] [stdout]    --> src/vm/jit/arch/common/core.rs:505:19
[INFO] [stdout]     |
[INFO] [stdout] 505 |             args: args.to_vec().into(),
[INFO] [stdout]     |                   ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 505 -             args: args.to_vec().into(),
[INFO] [stdout] 505 +             args: args.to_vec(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 505 -             args: args.to_vec().into(),
[INFO] [stdout] 505 +             args: <tracked_alloc::Vec<machine_ir::types::MachineValue> as Into<_>>::into(args.to_vec()),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/arch/x86_64/backend.rs:748:21
[INFO] [stdout]     |
[INFO] [stdout] 748 |                     "x86_64 GP move requested for FP storage type".into(),
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 748 -                     "x86_64 GP move requested for FP storage type".into(),
[INFO] [stdout] 748 +                     "x86_64 GP move requested for FP storage type",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 748 -                     "x86_64 GP move requested for FP storage type".into(),
[INFO] [stdout] 748 +                     <&str as Into<_>>::into("x86_64 GP move requested for FP storage type"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/arch/x86_64/backend.rs:770:21
[INFO] [stdout]     |
[INFO] [stdout] 770 |                     "x86_64 GP cmov requested for FP storage type".into(),
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 770 -                     "x86_64 GP cmov requested for FP storage type".into(),
[INFO] [stdout] 770 +                     "x86_64 GP cmov requested for FP storage type",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 770 -                     "x86_64 GP cmov requested for FP storage type".into(),
[INFO] [stdout] 770 +                     <&str as Into<_>>::into("x86_64 GP cmov requested for FP storage type"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/arch/x86_64/control.rs:523:17
[INFO] [stdout]     |
[INFO] [stdout] 523 |                 "x86_64 cannot lower 32-bit GP pair scalar return".into(),
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 523 -                 "x86_64 cannot lower 32-bit GP pair scalar return".into(),
[INFO] [stdout] 523 +                 "x86_64 cannot lower 32-bit GP pair scalar return",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 523 -                 "x86_64 cannot lower 32-bit GP pair scalar return".into(),
[INFO] [stdout] 523 +                 <&str as Into<_>>::into("x86_64 cannot lower 32-bit GP pair scalar return"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/arch/x86_64/control.rs:654:46
[INFO] [stdout]     |
[INFO] [stdout] 654 |             .map_err(|_| WasmError::internal("x86_64 call frame delta exceeds i32".into()))?;
[INFO] [stdout]     |                                              ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 654 -             .map_err(|_| WasmError::internal("x86_64 call frame delta exceeds i32".into()))?;
[INFO] [stdout] 654 +             .map_err(|_| WasmError::internal("x86_64 call frame delta exceeds i32"))?;
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 654 -             .map_err(|_| WasmError::internal("x86_64 call frame delta exceeds i32".into()))?;
[INFO] [stdout] 654 +             .map_err(|_| WasmError::internal(<&str as Into<_>>::into("x86_64 call frame delta exceeds i32")))?;
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/arch/x86_64/control.rs:675:17
[INFO] [stdout]     |
[INFO] [stdout] 675 |                 "x86_64 cannot lower 32-bit GP pair scalar call result".into(),
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 675 -                 "x86_64 cannot lower 32-bit GP pair scalar call result".into(),
[INFO] [stdout] 675 +                 "x86_64 cannot lower 32-bit GP pair scalar call result",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 675 -                 "x86_64 cannot lower 32-bit GP pair scalar call result".into(),
[INFO] [stdout] 675 +                 <&str as Into<_>>::into("x86_64 cannot lower 32-bit GP pair scalar call result"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/arch/x86_64/control.rs:840:17
[INFO] [stdout]     |
[INFO] [stdout] 840 |                 "x86_64 MachineIR jump table requires at least one entry".into(),
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 840 -                 "x86_64 MachineIR jump table requires at least one entry".into(),
[INFO] [stdout] 840 +                 "x86_64 MachineIR jump table requires at least one entry",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 840 -                 "x86_64 MachineIR jump table requires at least one entry".into(),
[INFO] [stdout] 840 +                 <&str as Into<_>>::into("x86_64 MachineIR jump table requires at least one entry"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/arch/x86_64/inst.rs:107:17
[INFO] [stdout]     |
[INFO] [stdout] 107 |                 "x86_64 backend received Int64PairBinary; 32-bit legalized MachineIR should not reach x86_64 codegen".into(),
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 107 -                 "x86_64 backend received Int64PairBinary; 32-bit legalized MachineIR should not reach x86_64 codegen".into(),
[INFO] [stdout] 107 +                 "x86_64 backend received Int64PairBinary; 32-bit legalized MachineIR should not reach x86_64 codegen",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 107 -                 "x86_64 backend received Int64PairBinary; 32-bit legalized MachineIR should not reach x86_64 codegen".into(),
[INFO] [stdout] 107 +                 <&str as Into<_>>::into("x86_64 backend received Int64PairBinary; 32-bit legalized MachineIR should not reach x86_64 codegen"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/arch/x86_64/inst.rs:110:17
[INFO] [stdout]     |
[INFO] [stdout] 110 |                 "x86_64 backend received Int64PairUnary; 32-bit legalized MachineIR should not reach x86_64 codegen".into(),
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 110 -                 "x86_64 backend received Int64PairUnary; 32-bit legalized MachineIR should not reach x86_64 codegen".into(),
[INFO] [stdout] 110 +                 "x86_64 backend received Int64PairUnary; 32-bit legalized MachineIR should not reach x86_64 codegen",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 110 -                 "x86_64 backend received Int64PairUnary; 32-bit legalized MachineIR should not reach x86_64 codegen".into(),
[INFO] [stdout] 110 +                 <&str as Into<_>>::into("x86_64 backend received Int64PairUnary; 32-bit legalized MachineIR should not reach x86_64 codegen"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/arch/x86_64/inst.rs:113:17
[INFO] [stdout]     |
[INFO] [stdout] 113 |                 "x86_64 backend received Int64PairDivRem; 32-bit legalized MachineIR should not reach x86_64 codegen".into(),
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 113 -                 "x86_64 backend received Int64PairDivRem; 32-bit legalized MachineIR should not reach x86_64 codegen".into(),
[INFO] [stdout] 113 +                 "x86_64 backend received Int64PairDivRem; 32-bit legalized MachineIR should not reach x86_64 codegen",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 113 -                 "x86_64 backend received Int64PairDivRem; 32-bit legalized MachineIR should not reach x86_64 codegen".into(),
[INFO] [stdout] 113 +                 <&str as Into<_>>::into("x86_64 backend received Int64PairDivRem; 32-bit legalized MachineIR should not reach x86_64 codegen"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/arch/x86_64/inst.rs:116:17
[INFO] [stdout]     |
[INFO] [stdout] 116 |                 "x86_64 backend received Int64PairShift; 32-bit legalized MachineIR should not reach x86_64 codegen".into(),
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 116 -                 "x86_64 backend received Int64PairShift; 32-bit legalized MachineIR should not reach x86_64 codegen".into(),
[INFO] [stdout] 116 +                 "x86_64 backend received Int64PairShift; 32-bit legalized MachineIR should not reach x86_64 codegen",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 116 -                 "x86_64 backend received Int64PairShift; 32-bit legalized MachineIR should not reach x86_64 codegen".into(),
[INFO] [stdout] 116 +                 <&str as Into<_>>::into("x86_64 backend received Int64PairShift; 32-bit legalized MachineIR should not reach x86_64 codegen"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/arch/x86_64/inst.rs:119:17
[INFO] [stdout]     |
[INFO] [stdout] 119 |                 "x86_64 backend received Int64MulFromSignExt32; this peephole only fires on 32-bit GP backends".into(),
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 119 -                 "x86_64 backend received Int64MulFromSignExt32; this peephole only fires on 32-bit GP backends".into(),
[INFO] [stdout] 119 +                 "x86_64 backend received Int64MulFromSignExt32; this peephole only fires on 32-bit GP backends",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 119 -                 "x86_64 backend received Int64MulFromSignExt32; this peephole only fires on 32-bit GP backends".into(),
[INFO] [stdout] 119 +                 <&str as Into<_>>::into("x86_64 backend received Int64MulFromSignExt32; this peephole only fires on 32-bit GP backends"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/arch/x86_64/inst.rs:200:17
[INFO] [stdout]     |
[INFO] [stdout] 200 |                 "x86_64 backend received ConvertI64PairToFloat; 32-bit legalized MachineIR should not reach x86_64 codegen".into(),
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 200 -                 "x86_64 backend received ConvertI64PairToFloat; 32-bit legalized MachineIR should not reach x86_64 codegen".into(),
[INFO] [stdout] 200 +                 "x86_64 backend received ConvertI64PairToFloat; 32-bit legalized MachineIR should not reach x86_64 codegen",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 200 -                 "x86_64 backend received ConvertI64PairToFloat; 32-bit legalized MachineIR should not reach x86_64 codegen".into(),
[INFO] [stdout] 200 +                 <&str as Into<_>>::into("x86_64 backend received ConvertI64PairToFloat; 32-bit legalized MachineIR should not reach x86_64 codegen"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/arch/x86_64/inst.rs:203:17
[INFO] [stdout]     |
[INFO] [stdout] 203 |                 "x86_64 backend received Int64PairCompare; 32-bit legalized MachineIR should not reach x86_64 codegen".into(),
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 203 -                 "x86_64 backend received Int64PairCompare; 32-bit legalized MachineIR should not reach x86_64 codegen".into(),
[INFO] [stdout] 203 +                 "x86_64 backend received Int64PairCompare; 32-bit legalized MachineIR should not reach x86_64 codegen",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 203 -                 "x86_64 backend received Int64PairCompare; 32-bit legalized MachineIR should not reach x86_64 codegen".into(),
[INFO] [stdout] 203 +                 <&str as Into<_>>::into("x86_64 backend received Int64PairCompare; 32-bit legalized MachineIR should not reach x86_64 codegen"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/arch/x86_64/inst.rs:206:17
[INFO] [stdout]     |
[INFO] [stdout] 206 |                 "x86_64 backend received ConvertFloatToI64Pair; 32-bit legalized MachineIR should not reach x86_64 codegen".into(),
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 206 -                 "x86_64 backend received ConvertFloatToI64Pair; 32-bit legalized MachineIR should not reach x86_64 codegen".into(),
[INFO] [stdout] 206 +                 "x86_64 backend received ConvertFloatToI64Pair; 32-bit legalized MachineIR should not reach x86_64 codegen",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 206 -                 "x86_64 backend received ConvertFloatToI64Pair; 32-bit legalized MachineIR should not reach x86_64 codegen".into(),
[INFO] [stdout] 206 +                 <&str as Into<_>>::into("x86_64 backend received ConvertFloatToI64Pair; 32-bit legalized MachineIR should not reach x86_64 codegen"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/arch/x86_64/inst.rs:209:17
[INFO] [stdout]     |
[INFO] [stdout] 209 |                 "x86_64 backend received ReinterpretF64ToI64Pair; 32-bit legalized MachineIR should not reach x86_64 codegen".into(),
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 209 -                 "x86_64 backend received ReinterpretF64ToI64Pair; 32-bit legalized MachineIR should not reach x86_64 codegen".into(),
[INFO] [stdout] 209 +                 "x86_64 backend received ReinterpretF64ToI64Pair; 32-bit legalized MachineIR should not reach x86_64 codegen",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 209 -                 "x86_64 backend received ReinterpretF64ToI64Pair; 32-bit legalized MachineIR should not reach x86_64 codegen".into(),
[INFO] [stdout] 209 +                 <&str as Into<_>>::into("x86_64 backend received ReinterpretF64ToI64Pair; 32-bit legalized MachineIR should not reach x86_64 codegen"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/arch/x86_64/inst.rs:212:17
[INFO] [stdout]     |
[INFO] [stdout] 212 |                 "x86_64 backend received ReinterpretI64PairToF64; 32-bit legalized MachineIR should not reach x86_64 codegen".into(),
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 212 -                 "x86_64 backend received ReinterpretI64PairToF64; 32-bit legalized MachineIR should not reach x86_64 codegen".into(),
[INFO] [stdout] 212 +                 "x86_64 backend received ReinterpretI64PairToF64; 32-bit legalized MachineIR should not reach x86_64 codegen",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 212 -                 "x86_64 backend received ReinterpretI64PairToF64; 32-bit legalized MachineIR should not reach x86_64 codegen".into(),
[INFO] [stdout] 212 +                 <&str as Into<_>>::into("x86_64 backend received ReinterpretI64PairToF64; 32-bit legalized MachineIR should not reach x86_64 codegen"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/arch/x86_64/inst.rs:412:25
[INFO] [stdout]     |
[INFO] [stdout] 412 |                         "x86_64 backend received pair-valued struct.get".into(),
[INFO] [stdout]     |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 412 -                         "x86_64 backend received pair-valued struct.get".into(),
[INFO] [stdout] 412 +                         "x86_64 backend received pair-valued struct.get",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 412 -                         "x86_64 backend received pair-valued struct.get".into(),
[INFO] [stdout] 412 +                         <&str as Into<_>>::into("x86_64 backend received pair-valued struct.get"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/arch/x86_64/inst.rs:440:25
[INFO] [stdout]     |
[INFO] [stdout] 440 |                         "x86_64 backend received pair-valued struct.set".into(),
[INFO] [stdout]     |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 440 -                         "x86_64 backend received pair-valued struct.set".into(),
[INFO] [stdout] 440 +                         "x86_64 backend received pair-valued struct.set",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 440 -                         "x86_64 backend received pair-valued struct.set".into(),
[INFO] [stdout] 440 +                         <&str as Into<_>>::into("x86_64 backend received pair-valued struct.set"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/arch/x86_64/inst.rs:461:25
[INFO] [stdout]     |
[INFO] [stdout] 461 |                         "x86_64 backend received pair-valued array.new".into(),
[INFO] [stdout]     |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 461 -                         "x86_64 backend received pair-valued array.new".into(),
[INFO] [stdout] 461 +                         "x86_64 backend received pair-valued array.new",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 461 -                         "x86_64 backend received pair-valued array.new".into(),
[INFO] [stdout] 461 +                         <&str as Into<_>>::into("x86_64 backend received pair-valued array.new"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/arch/x86_64/inst.rs:543:25
[INFO] [stdout]     |
[INFO] [stdout] 543 |                         "x86_64 backend received pair-valued array.get".into(),
[INFO] [stdout]     |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 543 -                         "x86_64 backend received pair-valued array.get".into(),
[INFO] [stdout] 543 +                         "x86_64 backend received pair-valued array.get",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 543 -                         "x86_64 backend received pair-valued array.get".into(),
[INFO] [stdout] 543 +                         <&str as Into<_>>::into("x86_64 backend received pair-valued array.get"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/arch/x86_64/inst.rs:571:25
[INFO] [stdout]     |
[INFO] [stdout] 571 |                         "x86_64 backend received pair-valued array.set".into(),
[INFO] [stdout]     |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 571 -                         "x86_64 backend received pair-valued array.set".into(),
[INFO] [stdout] 571 +                         "x86_64 backend received pair-valued array.set",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 571 -                         "x86_64 backend received pair-valued array.set".into(),
[INFO] [stdout] 571 +                         <&str as Into<_>>::into("x86_64 backend received pair-valued array.set"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/arch/x86_64/inst.rs:593:25
[INFO] [stdout]     |
[INFO] [stdout] 593 |                         "x86_64 backend received pair-valued array.fill".into(),
[INFO] [stdout]     |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 593 -                         "x86_64 backend received pair-valued array.fill".into(),
[INFO] [stdout] 593 +                         "x86_64 backend received pair-valued array.fill",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 593 -                         "x86_64 backend received pair-valued array.fill".into(),
[INFO] [stdout] 593 +                         <&str as Into<_>>::into("x86_64 backend received pair-valued array.fill"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/arch/x86_64/inst.rs:860:21
[INFO] [stdout]     |
[INFO] [stdout] 860 | /                     "x86_64 MachineIR backend does not support narrow integer loads into FP regs"
[INFO] [stdout] 861 | |                         .into(),
[INFO] [stdout]     | |_______________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 860 -                     "x86_64 MachineIR backend does not support narrow integer loads into FP regs"
[INFO] [stdout] 861 -                         .into(),
[INFO] [stdout] 860 +                     "x86_64 MachineIR backend does not support narrow integer loads into FP regs",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 860 -                     "x86_64 MachineIR backend does not support narrow integer loads into FP regs"
[INFO] [stdout] 861 -                         .into(),
[INFO] [stdout] 860 +                     <&str as Into<_>>::into("x86_64 MachineIR backend does not support narrow integer loads into FP regs"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/arch/x86_64/inst.rs:902:21
[INFO] [stdout]     |
[INFO] [stdout] 902 |                     "x86_64 MachineIR backend does not support sign-extending 64-bit loads".into(),
[INFO] [stdout]     |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 902 -                     "x86_64 MachineIR backend does not support sign-extending 64-bit loads".into(),
[INFO] [stdout] 902 +                     "x86_64 MachineIR backend does not support sign-extending 64-bit loads",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 902 -                     "x86_64 MachineIR backend does not support sign-extending 64-bit loads".into(),
[INFO] [stdout] 902 +                     <&str as Into<_>>::into("x86_64 MachineIR backend does not support sign-extending 64-bit loads"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/arch/x86_64/inst.rs:992:21
[INFO] [stdout]     |
[INFO] [stdout] 992 | /                     "x86_64 MachineIR backend does not support narrow integer loads into FP regs"
[INFO] [stdout] 993 | |                         .into(),
[INFO] [stdout]     | |_______________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 992 -                     "x86_64 MachineIR backend does not support narrow integer loads into FP regs"
[INFO] [stdout] 993 -                         .into(),
[INFO] [stdout] 992 +                     "x86_64 MachineIR backend does not support narrow integer loads into FP regs",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 992 -                     "x86_64 MachineIR backend does not support narrow integer loads into FP regs"
[INFO] [stdout] 993 -                         .into(),
[INFO] [stdout] 992 +                     <&str as Into<_>>::into("x86_64 MachineIR backend does not support narrow integer loads into FP regs"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/vm/jit/arch/x86_64/inst.rs:1038:21
[INFO] [stdout]      |
[INFO] [stdout] 1038 |                     "x86_64 MachineIR backend does not support sign-extending 64-bit loads".into(),
[INFO] [stdout]      |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1038 -                     "x86_64 MachineIR backend does not support sign-extending 64-bit loads".into(),
[INFO] [stdout] 1038 +                     "x86_64 MachineIR backend does not support sign-extending 64-bit loads",
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1038 -                     "x86_64 MachineIR backend does not support sign-extending 64-bit loads".into(),
[INFO] [stdout] 1038 +                     <&str as Into<_>>::into("x86_64 MachineIR backend does not support sign-extending 64-bit loads"),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/vm/jit/arch/x86_64/inst.rs:1070:29
[INFO] [stdout]      |
[INFO] [stdout] 1070 | ...                   "x86_64 MachineIR backend does not support narrow FP stores".into(),
[INFO] [stdout]      |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1070 -                             "x86_64 MachineIR backend does not support narrow FP stores".into(),
[INFO] [stdout] 1070 +                             "x86_64 MachineIR backend does not support narrow FP stores",
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1070 -                             "x86_64 MachineIR backend does not support narrow FP stores".into(),
[INFO] [stdout] 1070 +                             <&str as Into<_>>::into("x86_64 MachineIR backend does not support narrow FP stores"),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/vm/jit/arch/x86_64/inst.rs:1145:29
[INFO] [stdout]      |
[INFO] [stdout] 1145 | ...                   "x86_64 MachineIR backend does not support narrow FP stores".into(),
[INFO] [stdout]      |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1145 -                             "x86_64 MachineIR backend does not support narrow FP stores".into(),
[INFO] [stdout] 1145 +                             "x86_64 MachineIR backend does not support narrow FP stores",
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1145 -                             "x86_64 MachineIR backend does not support narrow FP stores".into(),
[INFO] [stdout] 1145 +                             <&str as Into<_>>::into("x86_64 MachineIR backend does not support narrow FP stores"),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/vm/jit/debug/ir_dump.rs:595:5
[INFO] [stdout]     |
[INFO] [stdout] 595 | /     bindings
[INFO] [stdout] 596 | |         .iter()
[INFO] [stdout] 597 | |         .map(|b| format!("v{}=v{}", b.param.0, b.value.0))
[INFO] [stdout] 598 | |         .collect::<collections::Vec<_>>()
[INFO] [stdout] 599 | |         .join(", ")
[INFO] [stdout] 600 | |         .into()
[INFO] [stdout]     | |_______________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 599 -         .join(", ")
[INFO] [stdout] 600 -         .into()
[INFO] [stdout] 599 +         .join(", ")
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 595 ~     <String as Into<_>>::into(bindings
[INFO] [stdout] 596 |         .iter()
[INFO] [stdout] 597 |         .map(|b| format!("v{}=v{}", b.param.0, b.value.0))
[INFO] [stdout] 598 |         .collect::<collections::Vec<_>>()
[INFO] [stdout] 599 ~         .join(", "))
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]    --> src/vm/jit/debug/ir_dump.rs:604:5
[INFO] [stdout]     |
[INFO] [stdout] 604 | /     ops.iter()
[INFO] [stdout] 605 | |         .map(|op| match op.decode() {
[INFO] [stdout] 606 | |             DecodedOperand::None => String::from("_"),
[INFO] [stdout] 607 | |             DecodedOperand::Value(v) => format!("v{}", v.0),
[INFO] [stdout] ...   |
[INFO] [stdout] 614 | |         .join(", ")
[INFO] [stdout] 615 | |         .into()
[INFO] [stdout]     | |_______________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 614 -         .join(", ")
[INFO] [stdout] 615 -         .into()
[INFO] [stdout] 614 +         .join(", ")
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 604 ~     <String as Into<_>>::into(ops.iter()
[INFO] [stdout] 605 |         .map(|op| match op.decode() {
[INFO] [stdout] ...
[INFO] [stdout] 613 |         .collect::<collections::Vec<_>>()
[INFO] [stdout] 614 ~         .join(", "))
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]     --> src/vm/jit/debug/ir_dump.rs:1777:5
[INFO] [stdout]      |
[INFO] [stdout] 1777 | /     args.lane_args
[INFO] [stdout] 1778 | |         .iter()
[INFO] [stdout] 1779 | |         .map(|arg| match arg {
[INFO] [stdout] 1780 | |             MachineCallLaneArg::Gp {
[INFO] [stdout] ...    |
[INFO] [stdout] 1806 | |         .join(", ")
[INFO] [stdout] 1807 | |         .into()
[INFO] [stdout]      | |_______________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1806 -         .join(", ")
[INFO] [stdout] 1807 -         .into()
[INFO] [stdout] 1806 +         .join(", ")
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1777 ~     <String as Into<_>>::into(args.lane_args
[INFO] [stdout] 1778 |         .iter()
[INFO] [stdout]  ...
[INFO] [stdout] 1805 |         .collect::<collections::Vec<_>>()
[INFO] [stdout] 1806 ~         .join(", "))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `String`
[INFO] [stdout]     --> src/vm/jit/debug/ir_dump.rs:1875:5
[INFO] [stdout]      |
[INFO] [stdout] 1875 | /     args.iter()
[INFO] [stdout] 1876 | |         .map(mval)
[INFO] [stdout] 1877 | |         .collect::<collections::Vec<_>>()
[INFO] [stdout] 1878 | |         .join(", ")
[INFO] [stdout] 1879 | |         .into()
[INFO] [stdout]      | |_______________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1878 -         .join(", ")
[INFO] [stdout] 1879 -         .into()
[INFO] [stdout] 1878 +         .join(", ")
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1875 ~     <String as Into<_>>::into(args.iter()
[INFO] [stdout] 1876 |         .map(mval)
[INFO] [stdout] 1877 |         .collect::<collections::Vec<_>>()
[INFO] [stdout] 1878 ~         .join(", "))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `tracked_alloc::Vec<u8>`
[INFO] [stdout]    --> src/vm/jit/instantiate.rs:812:36
[INFO] [stdout]     |
[INFO] [stdout] 812 |             .map(|d| DataInst::new(d.get_init().to_vec().into()))
[INFO] [stdout]     |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 812 -             .map(|d| DataInst::new(d.get_init().to_vec().into()))
[INFO] [stdout] 812 +             .map(|d| DataInst::new(d.get_init().to_vec()))
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 812 -             .map(|d| DataInst::new(d.get_init().to_vec().into()))
[INFO] [stdout] 812 +             .map(|d| DataInst::new(<tracked_alloc::Vec<u8> as Into<_>>::into(d.get_init().to_vec())))
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/vm/jit/instantiate.rs:1362:55
[INFO] [stdout]      |
[INFO] [stdout] 1362 |                     .ok_or_else(|| WasmError::invalid("element function index out of range".into()))
[INFO] [stdout]      |                                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1362 -                     .ok_or_else(|| WasmError::invalid("element function index out of range".into()))
[INFO] [stdout] 1362 +                     .ok_or_else(|| WasmError::invalid("element function index out of range"))
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1362 -                     .ok_or_else(|| WasmError::invalid("element function index out of range".into()))
[INFO] [stdout] 1362 +                     .ok_or_else(|| WasmError::invalid(<&str as Into<_>>::into("element function index out of range")))
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/vm/jit/instantiate.rs:1374:25
[INFO] [stdout]      |
[INFO] [stdout] 1374 |                         "element init must be a reference".into(),
[INFO] [stdout]      |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1374 -                         "element init must be a reference".into(),
[INFO] [stdout] 1374 +                         "element init must be a reference",
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1374 -                         "element init must be a reference".into(),
[INFO] [stdout] 1374 +                         <&str as Into<_>>::into("element init must be a reference"),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `tracked_alloc::Vec<u8>`
[INFO] [stdout]    --> src/vm/jit/machine/lower_cache_layout.rs:994:60
[INFO] [stdout]     |
[INFO] [stdout] 994 |                     let preserve: collections::Vec<Lane> = layout.to_vec().into();
[INFO] [stdout]     |                                                            ^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 994 -                     let preserve: collections::Vec<Lane> = layout.to_vec().into();
[INFO] [stdout] 994 +                     let preserve: collections::Vec<Lane> = layout.to_vec();
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 994 -                     let preserve: collections::Vec<Lane> = layout.to_vec().into();
[INFO] [stdout] 994 +                     let preserve: collections::Vec<Lane> = <tracked_alloc::Vec<u8> as Into<_>>::into(layout.to_vec());
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/vm/jit/machine/lower_cache_layout.rs:1037:25
[INFO] [stdout]      |
[INFO] [stdout] 1037 |                         "FP cache exit layout unexpectedly failed without a feasible hole".into(),
[INFO] [stdout]      |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1037 -                         "FP cache exit layout unexpectedly failed without a feasible hole".into(),
[INFO] [stdout] 1037 +                         "FP cache exit layout unexpectedly failed without a feasible hole",
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1037 -                         "FP cache exit layout unexpectedly failed without a feasible hole".into(),
[INFO] [stdout] 1037 +                         <&str as Into<_>>::into("FP cache exit layout unexpectedly failed without a feasible hole"),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `tracked_alloc::Vec<u8>`
[INFO] [stdout]     --> src/vm/jit/machine/lower_cache_layout.rs:1061:64
[INFO] [stdout]      |
[INFO] [stdout] 1061 |                         let preserve: collections::Vec<Lane> = layout.to_vec().into();
[INFO] [stdout]      |                                                                ^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1061 -                         let preserve: collections::Vec<Lane> = layout.to_vec().into();
[INFO] [stdout] 1061 +                         let preserve: collections::Vec<Lane> = layout.to_vec();
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1061 -                         let preserve: collections::Vec<Lane> = layout.to_vec().into();
[INFO] [stdout] 1061 +                         let preserve: collections::Vec<Lane> = <tracked_alloc::Vec<u8> as Into<_>>::into(layout.to_vec());
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/vm/jit/machine/lower_cache_layout.rs:1104:29
[INFO] [stdout]      |
[INFO] [stdout] 1104 | / ...                   "FP cache exit layout unexpectedly failed without a feasible hole"
[INFO] [stdout] 1105 | | ...                       .into(),
[INFO] [stdout]      | |_________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1104 -                             "FP cache exit layout unexpectedly failed without a feasible hole"
[INFO] [stdout] 1105 -                                 .into(),
[INFO] [stdout] 1104 +                             "FP cache exit layout unexpectedly failed without a feasible hole",
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1104 -                             "FP cache exit layout unexpectedly failed without a feasible hole"
[INFO] [stdout] 1105 -                                 .into(),
[INFO] [stdout] 1104 +                             <&str as Into<_>>::into("FP cache exit layout unexpectedly failed without a feasible hole"),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/vm/jit/machine/lower_cache_layout.rs:1262:13
[INFO] [stdout]      |
[INFO] [stdout] 1262 |             "FP cache lane layout unexpectedly failed without a feasible hole".into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1262 -             "FP cache lane layout unexpectedly failed without a feasible hole".into(),
[INFO] [stdout] 1262 +             "FP cache lane layout unexpectedly failed without a feasible hole",
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1262 -             "FP cache lane layout unexpectedly failed without a feasible hole".into(),
[INFO] [stdout] 1262 +             <&str as Into<_>>::into("FP cache lane layout unexpectedly failed without a feasible hole"),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `tracked_alloc::Vec<u8>`
[INFO] [stdout]     --> src/vm/jit/machine/lower_cache_layout.rs:1352:41
[INFO] [stdout]      |
[INFO] [stdout] 1352 |             *best = Some((current_cost, current.to_vec().into()));
[INFO] [stdout]      |                                         ^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1352 -             *best = Some((current_cost, current.to_vec().into()));
[INFO] [stdout] 1352 +             *best = Some((current_cost, current.to_vec()));
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1352 -             *best = Some((current_cost, current.to_vec().into()));
[INFO] [stdout] 1352 +             *best = Some((current_cost, <tracked_alloc::Vec<u8> as Into<_>>::into(current.to_vec())));
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/vm/jit/machine/lower_cache_layout.rs:1585:13
[INFO] [stdout]      |
[INFO] [stdout] 1585 |             "unsupported cache lane segment width for bank".into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1585 -             "unsupported cache lane segment width for bank".into(),
[INFO] [stdout] 1585 +             "unsupported cache lane segment width for bank",
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1585 -             "unsupported cache lane segment width for bank".into(),
[INFO] [stdout] 1585 +             <&str as Into<_>>::into("unsupported cache lane segment width for bank"),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/vm/jit/machine/lower_call.rs:68:17
[INFO] [stdout]    |
[INFO] [stdout] 68 | /                 "direct local call passes more arguments than fit in the callee local prefix"
[INFO] [stdout] 69 | |                     .into(),
[INFO] [stdout]    | |___________________________^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 68 -                 "direct local call passes more arguments than fit in the callee local prefix"
[INFO] [stdout] 69 -                     .into(),
[INFO] [stdout] 68 +                 "direct local call passes more arguments than fit in the callee local prefix",
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 68 -                 "direct local call passes more arguments than fit in the callee local prefix"
[INFO] [stdout] 69 -                     .into(),
[INFO] [stdout] 68 +                 <&str as Into<_>>::into("direct local call passes more arguments than fit in the callee local prefix"),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/vm/jit/machine/lower_call.rs:74:17
[INFO] [stdout]    |
[INFO] [stdout] 74 | /                 "direct local call result span does not match the callee return-result contract"
[INFO] [stdout] 75 | |                     .into(),
[INFO] [stdout]    | |___________________________^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 74 -                 "direct local call result span does not match the callee return-result contract"
[INFO] [stdout] 75 -                     .into(),
[INFO] [stdout] 74 +                 "direct local call result span does not match the callee return-result contract",
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 74 -                 "direct local call result span does not match the callee return-result contract"
[INFO] [stdout] 75 -                     .into(),
[INFO] [stdout] 74 +                 <&str as Into<_>>::into("direct local call result span does not match the callee return-result contract"),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/machine/lower_call.rs:164:17
[INFO] [stdout]     |
[INFO] [stdout] 164 | /                 "direct local tail call passes more arguments than fit in the callee local prefix"
[INFO] [stdout] 165 | |                     .into(),
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 164 -                 "direct local tail call passes more arguments than fit in the callee local prefix"
[INFO] [stdout] 165 -                     .into(),
[INFO] [stdout] 164 +                 "direct local tail call passes more arguments than fit in the callee local prefix",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 164 -                 "direct local tail call passes more arguments than fit in the callee local prefix"
[INFO] [stdout] 165 -                     .into(),
[INFO] [stdout] 164 +                 <&str as Into<_>>::into("direct local tail call passes more arguments than fit in the callee local prefix"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/machine/lower_call.rs:171:17
[INFO] [stdout]     |
[INFO] [stdout] 171 | /                 "direct local tail call result span does not match the callee return-result contract"
[INFO] [stdout] 172 | |                     .into(),
[INFO] [stdout]     | |___________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 171 -                 "direct local tail call result span does not match the callee return-result contract"
[INFO] [stdout] 172 -                     .into(),
[INFO] [stdout] 171 +                 "direct local tail call result span does not match the callee return-result contract",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 171 -                 "direct local tail call result span does not match the callee return-result contract"
[INFO] [stdout] 172 -                     .into(),
[INFO] [stdout] 171 +                 <&str as Into<_>>::into("direct local tail call result span does not match the callee return-result contract"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/machine/lower_call.rs:337:17
[INFO] [stdout]     |
[INFO] [stdout] 337 |                 "live scalar call result requested for zero-result call".into(),
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 337 -                 "live scalar call result requested for zero-result call".into(),
[INFO] [stdout] 337 +                 "live scalar call result requested for zero-result call",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 337 -                 "live scalar call result requested for zero-result call".into(),
[INFO] [stdout] 337 +                 <&str as Into<_>>::into("live scalar call result requested for zero-result call"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/machine/lower_call.rs:342:17
[INFO] [stdout]     |
[INFO] [stdout] 342 |                 "live scalar call result requested for multi-result call".into(),
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 342 -                 "live scalar call result requested for multi-result call".into(),
[INFO] [stdout] 342 +                 "live scalar call result requested for multi-result call",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 342 -                 "live scalar call result requested for multi-result call".into(),
[INFO] [stdout] 342 +                 <&str as Into<_>>::into("live scalar call result requested for multi-result call"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/machine/lower_call.rs:351:25
[INFO] [stdout]     |
[INFO] [stdout] 351 |                         "live GP scalar call result type does not match callee return ABI".into(),
[INFO] [stdout]     |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 351 -                         "live GP scalar call result type does not match callee return ABI".into(),
[INFO] [stdout] 351 +                         "live GP scalar call result type does not match callee return ABI",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 351 -                         "live GP scalar call result type does not match callee return ABI".into(),
[INFO] [stdout] 351 +                         <&str as Into<_>>::into("live GP scalar call result type does not match callee return ABI"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/machine/lower_call.rs:368:25
[INFO] [stdout]     |
[INFO] [stdout] 368 |                         "live GP-pair call result type does not match callee return ABI".into(),
[INFO] [stdout]     |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 368 -                         "live GP-pair call result type does not match callee return ABI".into(),
[INFO] [stdout] 368 +                         "live GP-pair call result type does not match callee return ABI",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 368 -                         "live GP-pair call result type does not match callee return ABI".into(),
[INFO] [stdout] 368 +                         <&str as Into<_>>::into("live GP-pair call result type does not match callee return ABI"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/machine/lower_call.rs:388:25
[INFO] [stdout]     |
[INFO] [stdout] 388 |                         "live FP scalar call result type does not match callee return ABI".into(),
[INFO] [stdout]     |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 388 -                         "live FP scalar call result type does not match callee return ABI".into(),
[INFO] [stdout] 388 +                         "live FP scalar call result type does not match callee return ABI",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 388 -                         "live FP scalar call result type does not match callee return ABI".into(),
[INFO] [stdout] 388 +                         <&str as Into<_>>::into("live FP scalar call result type does not match callee return ABI"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/machine/lower_call.rs:402:37
[INFO] [stdout]     |
[INFO] [stdout] 402 |                 WasmError::internal("live scalar call result requires a scalar return ABI".into()),
[INFO] [stdout]     |                                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 402 -                 WasmError::internal("live scalar call result requires a scalar return ABI".into()),
[INFO] [stdout] 402 +                 WasmError::internal("live scalar call result requires a scalar return ABI"),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 402 -                 WasmError::internal("live scalar call result requires a scalar return ABI".into()),
[INFO] [stdout] 402 +                 WasmError::internal(<&str as Into<_>>::into("live scalar call result requires a scalar return ABI")),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/machine/lower_call.rs:426:17
[INFO] [stdout]     |
[INFO] [stdout] 426 |                 "runtime call scalar result cannot materialize v128 through scalar ABI".into(),
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 426 -                 "runtime call scalar result cannot materialize v128 through scalar ABI".into(),
[INFO] [stdout] 426 +                 "runtime call scalar result cannot materialize v128 through scalar ABI",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 426 -                 "runtime call scalar result cannot materialize v128 through scalar ABI".into(),
[INFO] [stdout] 426 +                 <&str as Into<_>>::into("runtime call scalar result cannot materialize v128 through scalar ABI"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `tracked_alloc::Vec<u8>`
[INFO] [stdout]   --> src/vm/jit/machine/lower_const_pool.rs:57:30
[INFO] [stdout]    |
[INFO] [stdout] 57 |     (align_of::<T>() as u32, bytes.to_vec().into())
[INFO] [stdout]    |                              ^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 57 -     (align_of::<T>() as u32, bytes.to_vec().into())
[INFO] [stdout] 57 +     (align_of::<T>() as u32, bytes.to_vec())
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 57 -     (align_of::<T>() as u32, bytes.to_vec().into())
[INFO] [stdout] 57 +     (align_of::<T>() as u32, <tracked_alloc::Vec<u8> as Into<_>>::into(bytes.to_vec()))
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `tracked_alloc::Vec<CachedCell>`
[INFO] [stdout]    --> src/vm/jit/machine/lower_context.rs:292:27
[INFO] [stdout]     |
[INFO] [stdout] 292 |             cached_cells: cached_cells.to_vec().into(),
[INFO] [stdout]     |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 292 -             cached_cells: cached_cells.to_vec().into(),
[INFO] [stdout] 292 +             cached_cells: cached_cells.to_vec(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 292 -             cached_cells: cached_cells.to_vec().into(),
[INFO] [stdout] 292 +             cached_cells: <tracked_alloc::Vec<CachedCell> as Into<_>>::into(cached_cells.to_vec()),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/vm/jit/machine/lower_context.rs:1034:25
[INFO] [stdout]      |
[INFO] [stdout] 1034 |                         "linear-value budget exhausted during cache alias materialization".into(),
[INFO] [stdout]      |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1034 -                         "linear-value budget exhausted during cache alias materialization".into(),
[INFO] [stdout] 1034 +                         "linear-value budget exhausted during cache alias materialization",
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1034 -                         "linear-value budget exhausted during cache alias materialization".into(),
[INFO] [stdout] 1034 +                         <&str as Into<_>>::into("linear-value budget exhausted during cache alias materialization"),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/vm/jit/machine/lower_inst.rs:80:25
[INFO] [stdout]    |
[INFO] [stdout] 80 | ...   "SSA-IR return reached native lowering with live linear SSA values; results must be published before return".into(),
[INFO] [stdout]    |       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 80 -                         "SSA-IR return reached native lowering with live linear SSA values; results must be published before return".into(),
[INFO] [stdout] 80 +                         "SSA-IR return reached native lowering with live linear SSA values; results must be published before return",
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 80 -                         "SSA-IR return reached native lowering with live linear SSA values; results must be published before return".into(),
[INFO] [stdout] 80 +                         <&str as Into<_>>::into("SSA-IR return reached native lowering with live linear SSA values; results must be published before return"),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/machine/lower_inst.rs:149:17
[INFO] [stdout]     |
[INFO] [stdout] 149 |                 "v128 scalar return reached machine lowering".into(),
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 149 -                 "v128 scalar return reached machine lowering".into(),
[INFO] [stdout] 149 +                 "v128 scalar return reached machine lowering",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 149 -                 "v128 scalar return reached machine lowering".into(),
[INFO] [stdout] 149 +                 <&str as Into<_>>::into("v128 scalar return reached machine lowering"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/machine/lower_inst.rs:241:29
[INFO] [stdout]     |
[INFO] [stdout] 241 | ...                   "stack-resident FP scalar return reached frame fallback".into(),
[INFO] [stdout]     |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 241 -                             "stack-resident FP scalar return reached frame fallback".into(),
[INFO] [stdout] 241 +                             "stack-resident FP scalar return reached frame fallback",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 241 -                             "stack-resident FP scalar return reached frame fallback".into(),
[INFO] [stdout] 241 +                             <&str as Into<_>>::into("stack-resident FP scalar return reached frame fallback"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/vm/jit/machine/lower_inst.rs:1725:25
[INFO] [stdout]      |
[INFO] [stdout] 1725 | /                         "missing SSA-IR edge binding for target param during native lowering"
[INFO] [stdout] 1726 | |                             .into(),
[INFO] [stdout]      | |___________________________________^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1725 -                         "missing SSA-IR edge binding for target param during native lowering"
[INFO] [stdout] 1726 -                             .into(),
[INFO] [stdout] 1725 +                         "missing SSA-IR edge binding for target param during native lowering",
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1725 -                         "missing SSA-IR edge binding for target param during native lowering"
[INFO] [stdout] 1726 -                             .into(),
[INFO] [stdout] 1725 +                         <&str as Into<_>>::into("missing SSA-IR edge binding for target param during native lowering"),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/vm/jit/machine/lower_leaf_special.rs:2809:17
[INFO] [stdout]      |
[INFO] [stdout] 2809 |                 "unexpected SIMD memory opcode in native lowering".into(),
[INFO] [stdout]      |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2809 -                 "unexpected SIMD memory opcode in native lowering".into(),
[INFO] [stdout] 2809 +                 "unexpected SIMD memory opcode in native lowering",
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2809 -                 "unexpected SIMD memory opcode in native lowering".into(),
[INFO] [stdout] 2809 +                 <&str as Into<_>>::into("unexpected SIMD memory opcode in native lowering"),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/vm/jit/machine/lower_leaf_special.rs:2827:17
[INFO] [stdout]      |
[INFO] [stdout] 2827 |                 "unexpected SIMD lane memory opcode in native lowering".into(),
[INFO] [stdout]      |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2827 -                 "unexpected SIMD lane memory opcode in native lowering".into(),
[INFO] [stdout] 2827 +                 "unexpected SIMD lane memory opcode in native lowering",
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2827 -                 "unexpected SIMD lane memory opcode in native lowering".into(),
[INFO] [stdout] 2827 +                 <&str as Into<_>>::into("unexpected SIMD lane memory opcode in native lowering"),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/vm/jit/machine/lower_module.rs:1165:21
[INFO] [stdout]      |
[INFO] [stdout] 1165 |                     "prepared SSA-IR uses inconsistent return result spans across blocks".into(),
[INFO] [stdout]      |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1165 -                     "prepared SSA-IR uses inconsistent return result spans across blocks".into(),
[INFO] [stdout] 1165 +                     "prepared SSA-IR uses inconsistent return result spans across blocks",
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1165 -                     "prepared SSA-IR uses inconsistent return result spans across blocks".into(),
[INFO] [stdout] 1165 +                     <&str as Into<_>>::into("prepared SSA-IR uses inconsistent return result spans across blocks"),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/vm/jit/machine/lower_module.rs:2420:17
[INFO] [stdout]      |
[INFO] [stdout] 2420 |                 "machine continuation blocks must be appended in id order".into(),
[INFO] [stdout]      |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2420 -                 "machine continuation blocks must be appended in id order".into(),
[INFO] [stdout] 2420 +                 "machine continuation blocks must be appended in id order",
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2420 -                 "machine continuation blocks must be appended in id order".into(),
[INFO] [stdout] 2420 +                 <&str as Into<_>>::into("machine continuation blocks must be appended in id order"),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/vm/jit/machine/lower_module.rs:2465:13
[INFO] [stdout]      |
[INFO] [stdout] 2465 |             "split continuation terminator does not branch to the continuation block".into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2465 -             "split continuation terminator does not branch to the continuation block".into(),
[INFO] [stdout] 2465 +             "split continuation terminator does not branch to the continuation block",
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2465 -             "split continuation terminator does not branch to the continuation block".into(),
[INFO] [stdout] 2465 +             <&str as Into<_>>::into("split continuation terminator does not branch to the continuation block"),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/vm/jit/machine/lower_module.rs:2594:17
[INFO] [stdout]      |
[INFO] [stdout] 2594 |                 "machine lowering emitted original blocks out of id order".into(),
[INFO] [stdout]      |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2594 -                 "machine lowering emitted original blocks out of id order".into(),
[INFO] [stdout] 2594 +                 "machine lowering emitted original blocks out of id order",
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2594 -                 "machine lowering emitted original blocks out of id order".into(),
[INFO] [stdout] 2594 +                 <&str as Into<_>>::into("machine lowering emitted original blocks out of id order"),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/vm/jit/machine/lower_module.rs:2605:17
[INFO] [stdout]      |
[INFO] [stdout] 2605 |                 "machine lowering did not produce every original block".into(),
[INFO] [stdout]      |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2605 -                 "machine lowering did not produce every original block".into(),
[INFO] [stdout] 2605 +                 "machine lowering did not produce every original block",
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2605 -                 "machine lowering did not produce every original block".into(),
[INFO] [stdout] 2605 +                 <&str as Into<_>>::into("machine lowering did not produce every original block"),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/vm/jit/machine/lower_regalloc.rs:60:17
[INFO] [stdout]    |
[INFO] [stdout] 60 |                 "native lowering requires at least one GP dynamic register".into(),
[INFO] [stdout]    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 60 -                 "native lowering requires at least one GP dynamic register".into(),
[INFO] [stdout] 60 +                 "native lowering requires at least one GP dynamic register",
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 60 -                 "native lowering requires at least one GP dynamic register".into(),
[INFO] [stdout] 60 +                 <&str as Into<_>>::into("native lowering requires at least one GP dynamic register"),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/machine/lower_regalloc.rs:317:25
[INFO] [stdout]     |
[INFO] [stdout] 317 | /                         "dynamic register budget exhausted while materializing constant operand"
[INFO] [stdout] 318 | |                             .into(),
[INFO] [stdout]     | |___________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 317 -                         "dynamic register budget exhausted while materializing constant operand"
[INFO] [stdout] 318 -                             .into(),
[INFO] [stdout] 317 +                         "dynamic register budget exhausted while materializing constant operand",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 317 -                         "dynamic register budget exhausted while materializing constant operand"
[INFO] [stdout] 318 -                             .into(),
[INFO] [stdout] 317 +                         <&str as Into<_>>::into("dynamic register budget exhausted while materializing constant operand"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/machine/lower_regalloc.rs:703:13
[INFO] [stdout]     |
[INFO] [stdout] 703 |             "machine register is not in the dynamic bank".into(),
[INFO] [stdout]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 703 -             "machine register is not in the dynamic bank".into(),
[INFO] [stdout] 703 +             "machine register is not in the dynamic bank",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 703 -             "machine register is not in the dynamic bank".into(),
[INFO] [stdout] 703 +             <&str as Into<_>>::into("machine register is not in the dynamic bank"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/machine/lower_regalloc.rs:863:13
[INFO] [stdout]     |
[INFO] [stdout] 863 |             "non-dynamic register cannot have a dynamic owner".into(),
[INFO] [stdout]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 863 -             "non-dynamic register cannot have a dynamic owner".into(),
[INFO] [stdout] 863 +             "non-dynamic register cannot have a dynamic owner",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 863 -             "non-dynamic register cannot have a dynamic owner".into(),
[INFO] [stdout] 863 +             <&str as Into<_>>::into("non-dynamic register cannot have a dynamic owner"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/vm/jit/machine/lower_simd.rs:19:17
[INFO] [stdout]    |
[INFO] [stdout] 19 |                 "SIMD lowering requires a 64-bit raw-handle ABI".into(),
[INFO] [stdout]    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 19 -                 "SIMD lowering requires a 64-bit raw-handle ABI".into(),
[INFO] [stdout] 19 +                 "SIMD lowering requires a 64-bit raw-handle ABI",
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 19 -                 "SIMD lowering requires a 64-bit raw-handle ABI".into(),
[INFO] [stdout] 19 +                 <&str as Into<_>>::into("SIMD lowering requires a 64-bit raw-handle ABI"),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/machine/lower_util.rs:224:13
[INFO] [stdout]     |
[INFO] [stdout] 224 |             "machine lowering expected exactly one result".into(),
[INFO] [stdout]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 224 -             "machine lowering expected exactly one result".into(),
[INFO] [stdout] 224 +             "machine lowering expected exactly one result",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 224 -             "machine lowering expected exactly one result".into(),
[INFO] [stdout] 224 +             <&str as Into<_>>::into("machine lowering expected exactly one result"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/machine/lower_util.rs:233:13
[INFO] [stdout]     |
[INFO] [stdout] 233 |             "machine lowering expected exactly one argument".into(),
[INFO] [stdout]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 233 -             "machine lowering expected exactly one argument".into(),
[INFO] [stdout] 233 +             "machine lowering expected exactly one argument",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 233 -             "machine lowering expected exactly one argument".into(),
[INFO] [stdout] 233 +             <&str as Into<_>>::into("machine lowering expected exactly one argument"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/machine/lower_util.rs:242:13
[INFO] [stdout]     |
[INFO] [stdout] 242 |             "machine lowering expected exactly two arguments".into(),
[INFO] [stdout]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 242 -             "machine lowering expected exactly two arguments".into(),
[INFO] [stdout] 242 +             "machine lowering expected exactly two arguments",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 242 -             "machine lowering expected exactly two arguments".into(),
[INFO] [stdout] 242 +             <&str as Into<_>>::into("machine lowering expected exactly two arguments"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/machine/lower_util.rs:253:13
[INFO] [stdout]     |
[INFO] [stdout] 253 |             "machine lowering expected exactly three arguments".into(),
[INFO] [stdout]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 253 -             "machine lowering expected exactly three arguments".into(),
[INFO] [stdout] 253 +             "machine lowering expected exactly three arguments",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 253 -             "machine lowering expected exactly three arguments".into(),
[INFO] [stdout] 253 +             <&str as Into<_>>::into("machine lowering expected exactly three arguments"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/machine/lower_util.rs:264:13
[INFO] [stdout]     |
[INFO] [stdout] 264 |             "machine lowering expected exactly four arguments".into(),
[INFO] [stdout]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 264 -             "machine lowering expected exactly four arguments".into(),
[INFO] [stdout] 264 +             "machine lowering expected exactly four arguments",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 264 -             "machine lowering expected exactly four arguments".into(),
[INFO] [stdout] 264 +             <&str as Into<_>>::into("machine lowering expected exactly four arguments"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/machine/lower_util.rs:275:13
[INFO] [stdout]     |
[INFO] [stdout] 275 |             "machine lowering expected exactly five arguments".into(),
[INFO] [stdout]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 275 -             "machine lowering expected exactly five arguments".into(),
[INFO] [stdout] 275 +             "machine lowering expected exactly five arguments",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 275 -             "machine lowering expected exactly five arguments".into(),
[INFO] [stdout] 275 +             <&str as Into<_>>::into("machine lowering expected exactly five arguments"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/vm/jit/machine/validate.rs:62:21
[INFO] [stdout]    |
[INFO] [stdout] 62 |                     "empty machine program must use entry block 0".into(),
[INFO] [stdout]    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 62 -                     "empty machine program must use entry block 0".into(),
[INFO] [stdout] 62 +                     "empty machine program must use entry block 0",
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 62 -                     "empty machine program must use entry block 0".into(),
[INFO] [stdout] 62 +                     <&str as Into<_>>::into("empty machine program must use entry block 0"),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/machine/validate.rs:338:25
[INFO] [stdout]     |
[INFO] [stdout] 338 |                         "machine Int64PairBinary requires a supported i64 binary op".into(),
[INFO] [stdout]     |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 338 -                         "machine Int64PairBinary requires a supported i64 binary op".into(),
[INFO] [stdout] 338 +                         "machine Int64PairBinary requires a supported i64 binary op",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 338 -                         "machine Int64PairBinary requires a supported i64 binary op".into(),
[INFO] [stdout] 338 +                         <&str as Into<_>>::into("machine Int64PairBinary requires a supported i64 binary op"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/machine/validate.rs:343:25
[INFO] [stdout]     |
[INFO] [stdout] 343 |                         "machine Int64PairBinary requires distinct low/high destinations".into(),
[INFO] [stdout]     |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 343 -                         "machine Int64PairBinary requires distinct low/high destinations".into(),
[INFO] [stdout] 343 +                         "machine Int64PairBinary requires distinct low/high destinations",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 343 -                         "machine Int64PairBinary requires distinct low/high destinations".into(),
[INFO] [stdout] 343 +                         <&str as Into<_>>::into("machine Int64PairBinary requires distinct low/high destinations"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/machine/validate.rs:361:25
[INFO] [stdout]     |
[INFO] [stdout] 361 | /                         "machine Int64MulFromSignExt32 requires distinct low/high destinations"
[INFO] [stdout] 362 | |                             .into(),
[INFO] [stdout]     | |___________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 361 -                         "machine Int64MulFromSignExt32 requires distinct low/high destinations"
[INFO] [stdout] 362 -                             .into(),
[INFO] [stdout] 361 +                         "machine Int64MulFromSignExt32 requires distinct low/high destinations",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 361 -                         "machine Int64MulFromSignExt32 requires distinct low/high destinations"
[INFO] [stdout] 362 -                             .into(),
[INFO] [stdout] 361 +                         <&str as Into<_>>::into("machine Int64MulFromSignExt32 requires distinct low/high destinations"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/machine/validate.rs:385:25
[INFO] [stdout]     |
[INFO] [stdout] 385 |                         "machine Int64PairDivRem requires distinct low/high destinations".into(),
[INFO] [stdout]     |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 385 -                         "machine Int64PairDivRem requires distinct low/high destinations".into(),
[INFO] [stdout] 385 +                         "machine Int64PairDivRem requires distinct low/high destinations",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 385 -                         "machine Int64PairDivRem requires distinct low/high destinations".into(),
[INFO] [stdout] 385 +                         <&str as Into<_>>::into("machine Int64PairDivRem requires distinct low/high destinations"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/machine/validate.rs:412:25
[INFO] [stdout]     |
[INFO] [stdout] 412 |                         "machine Int64PairUnary requires a supported i64 unary op".into(),
[INFO] [stdout]     |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 412 -                         "machine Int64PairUnary requires a supported i64 unary op".into(),
[INFO] [stdout] 412 +                         "machine Int64PairUnary requires a supported i64 unary op",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 412 -                         "machine Int64PairUnary requires a supported i64 unary op".into(),
[INFO] [stdout] 412 +                         <&str as Into<_>>::into("machine Int64PairUnary requires a supported i64 unary op"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/machine/validate.rs:417:25
[INFO] [stdout]     |
[INFO] [stdout] 417 |                         "machine Int64PairUnary requires distinct low/high destinations".into(),
[INFO] [stdout]     |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 417 -                         "machine Int64PairUnary requires distinct low/high destinations".into(),
[INFO] [stdout] 417 +                         "machine Int64PairUnary requires distinct low/high destinations",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 417 -                         "machine Int64PairUnary requires distinct low/high destinations".into(),
[INFO] [stdout] 417 +                         <&str as Into<_>>::into("machine Int64PairUnary requires distinct low/high destinations"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/machine/validate.rs:445:25
[INFO] [stdout]     |
[INFO] [stdout] 445 |                         "machine Int64PairShift requires a shift/rotate op".into(),
[INFO] [stdout]     |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 445 -                         "machine Int64PairShift requires a shift/rotate op".into(),
[INFO] [stdout] 445 +                         "machine Int64PairShift requires a shift/rotate op",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 445 -                         "machine Int64PairShift requires a shift/rotate op".into(),
[INFO] [stdout] 445 +                         <&str as Into<_>>::into("machine Int64PairShift requires a shift/rotate op"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/machine/validate.rs:450:25
[INFO] [stdout]     |
[INFO] [stdout] 450 |                         "machine Int64PairShift requires distinct low/high destinations".into(),
[INFO] [stdout]     |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 450 -                         "machine Int64PairShift requires distinct low/high destinations".into(),
[INFO] [stdout] 450 +                         "machine Int64PairShift requires distinct low/high destinations",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 450 -                         "machine Int64PairShift requires distinct low/high destinations".into(),
[INFO] [stdout] 450 +                         <&str as Into<_>>::into("machine Int64PairShift requires distinct low/high destinations"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/machine/validate.rs:516:25
[INFO] [stdout]     |
[INFO] [stdout] 516 |                         "machine ConvertFloatToI64Pair requires an i64 trunc/trunc_sat op".into(),
[INFO] [stdout]     |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 516 -                         "machine ConvertFloatToI64Pair requires an i64 trunc/trunc_sat op".into(),
[INFO] [stdout] 516 +                         "machine ConvertFloatToI64Pair requires an i64 trunc/trunc_sat op",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 516 -                         "machine ConvertFloatToI64Pair requires an i64 trunc/trunc_sat op".into(),
[INFO] [stdout] 516 +                         <&str as Into<_>>::into("machine ConvertFloatToI64Pair requires an i64 trunc/trunc_sat op"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/machine/validate.rs:534:25
[INFO] [stdout]     |
[INFO] [stdout] 534 | /                         "machine ConvertFloatToI64Pair requires distinct low/high destinations"
[INFO] [stdout] 535 | |                             .into(),
[INFO] [stdout]     | |___________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 534 -                         "machine ConvertFloatToI64Pair requires distinct low/high destinations"
[INFO] [stdout] 535 -                             .into(),
[INFO] [stdout] 534 +                         "machine ConvertFloatToI64Pair requires distinct low/high destinations",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 534 -                         "machine ConvertFloatToI64Pair requires distinct low/high destinations"
[INFO] [stdout] 535 -                             .into(),
[INFO] [stdout] 534 +                         <&str as Into<_>>::into("machine ConvertFloatToI64Pair requires distinct low/high destinations"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/machine/validate.rs:554:25
[INFO] [stdout]     |
[INFO] [stdout] 554 | /                         "machine ReinterpretF64ToI64Pair requires distinct low/high destinations"
[INFO] [stdout] 555 | |                             .into(),
[INFO] [stdout]     | |___________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 554 -                         "machine ReinterpretF64ToI64Pair requires distinct low/high destinations"
[INFO] [stdout] 555 -                             .into(),
[INFO] [stdout] 554 +                         "machine ReinterpretF64ToI64Pair requires distinct low/high destinations",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 554 -                         "machine ReinterpretF64ToI64Pair requires distinct low/high destinations"
[INFO] [stdout] 555 -                             .into(),
[INFO] [stdout] 554 +                         <&str as Into<_>>::into("machine ReinterpretF64ToI64Pair requires distinct low/high destinations"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/vm/jit/middle/ssa_ir/validate.rs:26:17
[INFO] [stdout]    |
[INFO] [stdout] 26 |                 "empty SSA-IR program must use entry block 0".into(),
[INFO] [stdout]    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 26 -                 "empty SSA-IR program must use entry block 0".into(),
[INFO] [stdout] 26 +                 "empty SSA-IR program must use entry block 0",
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 26 -                 "empty SSA-IR program must use entry block 0".into(),
[INFO] [stdout] 26 +                 <&str as Into<_>>::into("empty SSA-IR program must use entry block 0"),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `tracked_alloc::Vec<usize>`
[INFO] [stdout]    --> src/vm/jit/middle/discipline.rs:831:44
[INFO] [stdout]     |
[INFO] [stdout] 831 |             self.dealiases.push((slot, ty, positions.to_vec().into()));
[INFO] [stdout]     |                                            ^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 831 -             self.dealiases.push((slot, ty, positions.to_vec().into()));
[INFO] [stdout] 831 +             self.dealiases.push((slot, ty, positions.to_vec()));
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 831 -             self.dealiases.push((slot, ty, positions.to_vec().into()));
[INFO] [stdout] 831 +             self.dealiases.push((slot, ty, <tracked_alloc::Vec<usize> as Into<_>>::into(positions.to_vec())));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `tracked_alloc::Vec<value_type::ValueType>`
[INFO] [stdout]    --> src/vm/jit/middle/joint_plan/build.rs:214:13
[INFO] [stdout]     |
[INFO] [stdout] 214 |             self.type_stack[start..end].to_vec().into()
[INFO] [stdout]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 214 -             self.type_stack[start..end].to_vec().into()
[INFO] [stdout] 214 +             self.type_stack[start..end].to_vec()
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 214 -             self.type_stack[start..end].to_vec().into()
[INFO] [stdout] 214 +             <tracked_alloc::Vec<value_type::ValueType> as Into<_>>::into(self.type_stack[start..end].to_vec())
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `tracked_alloc::Vec<value_type::ValueType>`
[INFO] [stdout]    --> src/vm/jit/middle/joint_plan/build.rs:550:20
[INFO] [stdout]     |
[INFO] [stdout] 550 |             return types.to_vec().into();
[INFO] [stdout]     |                    ^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 550 -             return types.to_vec().into();
[INFO] [stdout] 550 +             return types.to_vec();
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 550 -             return types.to_vec().into();
[INFO] [stdout] 550 +             return <tracked_alloc::Vec<value_type::ValueType> as Into<_>>::into(types.to_vec());
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `tracked_alloc::Vec<bool>`
[INFO] [stdout]    --> src/vm/jit/middle/joint_plan/init_locals.rs:261:19
[INFO] [stdout]     |
[INFO] [stdout] 261 |             out = path.to_vec().into();
[INFO] [stdout]     |                   ^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 261 -             out = path.to_vec().into();
[INFO] [stdout] 261 +             out = path.to_vec();
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 261 -             out = path.to_vec().into();
[INFO] [stdout] 261 +             out = <tracked_alloc::Vec<bool> as Into<_>>::into(path.to_vec());
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `tracked_alloc::Vec<bool>`
[INFO] [stdout]    --> src/vm/jit/middle/joint_plan/init_locals.rs:275:46
[INFO] [stdout]     |
[INFO] [stdout] 275 |         (Some(a), None) | (None, Some(a)) => a.to_vec().into(),
[INFO] [stdout]     |                                              ^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 275 -         (Some(a), None) | (None, Some(a)) => a.to_vec().into(),
[INFO] [stdout] 275 +         (Some(a), None) | (None, Some(a)) => a.to_vec(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 275 -         (Some(a), None) | (None, Some(a)) => a.to_vec().into(),
[INFO] [stdout] 275 +         (Some(a), None) | (None, Some(a)) => <tracked_alloc::Vec<bool> as Into<_>>::into(a.to_vec()),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `tracked_alloc::Vec<middle::cell::CellId>`
[INFO] [stdout]    --> src/vm/jit/middle/rewrite/edge.rs:176:38
[INFO] [stdout]     |
[INFO] [stdout] 176 |                 ensure_cached_cells: plan.slot_arena[spans.ensure.range()].to_vec().into(),
[INFO] [stdout]     |                                      ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 176 -                 ensure_cached_cells: plan.slot_arena[spans.ensure.range()].to_vec().into(),
[INFO] [stdout] 176 +                 ensure_cached_cells: plan.slot_arena[spans.ensure.range()].to_vec(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 176 -                 ensure_cached_cells: plan.slot_arena[spans.ensure.range()].to_vec().into(),
[INFO] [stdout] 176 +                 ensure_cached_cells: <tracked_alloc::Vec<middle::cell::CellId> as Into<_>>::into(plan.slot_arena[spans.ensure.range()].to_vec()),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `tracked_alloc::Vec<middle::cell::CellId>`
[INFO] [stdout]    --> src/vm/jit/middle/rewrite/edge.rs:177:39
[INFO] [stdout]     |
[INFO] [stdout] 177 |                 reserve_cached_cells: plan.slot_arena[spans.reserve.range()].to_vec().into(),
[INFO] [stdout]     |                                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 177 -                 reserve_cached_cells: plan.slot_arena[spans.reserve.range()].to_vec().into(),
[INFO] [stdout] 177 +                 reserve_cached_cells: plan.slot_arena[spans.reserve.range()].to_vec(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 177 -                 reserve_cached_cells: plan.slot_arena[spans.reserve.range()].to_vec().into(),
[INFO] [stdout] 177 +                 reserve_cached_cells: <tracked_alloc::Vec<middle::cell::CellId> as Into<_>>::into(plan.slot_arena[spans.reserve.range()].to_vec()),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `tracked_alloc::Vec<middle::cell::CellId>`
[INFO] [stdout]    --> src/vm/jit/middle/rewrite/edge.rs:178:36
[INFO] [stdout]     |
[INFO] [stdout] 178 |                 drop_cached_cells: plan.slot_arena[spans.drop.range()].to_vec().into(),
[INFO] [stdout]     |                                    ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 178 -                 drop_cached_cells: plan.slot_arena[spans.drop.range()].to_vec().into(),
[INFO] [stdout] 178 +                 drop_cached_cells: plan.slot_arena[spans.drop.range()].to_vec(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 178 -                 drop_cached_cells: plan.slot_arena[spans.drop.range()].to_vec().into(),
[INFO] [stdout] 178 +                 drop_cached_cells: <tracked_alloc::Vec<middle::cell::CellId> as Into<_>>::into(plan.slot_arena[spans.drop.range()].to_vec()),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `tracked_alloc::Vec<middle::cell::CellId>`
[INFO] [stdout]    --> src/vm/jit/middle/rewrite/edge.rs:294:20
[INFO] [stdout]     |
[INFO] [stdout] 294 |         pred_exit: pred_exit.to_vec().into(),
[INFO] [stdout]     |                    ^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 294 -         pred_exit: pred_exit.to_vec().into(),
[INFO] [stdout] 294 +         pred_exit: pred_exit.to_vec(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 294 -         pred_exit: pred_exit.to_vec().into(),
[INFO] [stdout] 294 +         pred_exit: <tracked_alloc::Vec<middle::cell::CellId> as Into<_>>::into(pred_exit.to_vec()),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `tracked_alloc::Vec<middle::cell::CellId>`
[INFO] [stdout]    --> src/vm/jit/middle/rewrite/edge.rs:323:15
[INFO] [stdout]     |
[INFO] [stdout] 323 |         .push(pred_exit.to_vec().into());
[INFO] [stdout]     |               ^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 323 -         .push(pred_exit.to_vec().into());
[INFO] [stdout] 323 +         .push(pred_exit.to_vec());
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 323 -         .push(pred_exit.to_vec().into());
[INFO] [stdout] 323 +         .push(<tracked_alloc::Vec<middle::cell::CellId> as Into<_>>::into(pred_exit.to_vec()));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/middle/rewrite/function.rs:855:13
[INFO] [stdout]     |
[INFO] [stdout] 855 |             "control/return op must be block terminator".into(),
[INFO] [stdout]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 855 -             "control/return op must be block terminator".into(),
[INFO] [stdout] 855 +             "control/return op must be block terminator",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 855 -             "control/return op must be block terminator".into(),
[INFO] [stdout] 855 +             <&str as Into<_>>::into("control/return op must be block terminator"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `tracked_alloc::Vec<value_type::ValueType>`
[INFO] [stdout]     --> src/vm/jit/middle/rewrite/function.rs:1084:23
[INFO] [stdout]      |
[INFO] [stdout] 1084 |         result_types: result_types.to_vec().into(),
[INFO] [stdout]      |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1084 -         result_types: result_types.to_vec().into(),
[INFO] [stdout] 1084 +         result_types: result_types.to_vec(),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1084 -         result_types: result_types.to_vec().into(),
[INFO] [stdout] 1084 +         result_types: <tracked_alloc::Vec<value_type::ValueType> as Into<_>>::into(result_types.to_vec()),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `tracked_alloc::Vec<value_type::ValueType>`
[INFO] [stdout]     --> src/vm/jit/middle/rewrite/function.rs:1138:23
[INFO] [stdout]      |
[INFO] [stdout] 1138 |         result_types: result_types.to_vec().into(),
[INFO] [stdout]      |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1138 -         result_types: result_types.to_vec().into(),
[INFO] [stdout] 1138 +         result_types: result_types.to_vec(),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1138 -         result_types: result_types.to_vec().into(),
[INFO] [stdout] 1138 +         result_types: <tracked_alloc::Vec<value_type::ValueType> as Into<_>>::into(result_types.to_vec()),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `tracked_alloc::Vec<value_type::ValueType>`
[INFO] [stdout]     --> src/vm/jit/middle/rewrite/function.rs:1183:23
[INFO] [stdout]      |
[INFO] [stdout] 1183 |         result_types: result_types.to_vec().into(),
[INFO] [stdout]      |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1183 -         result_types: result_types.to_vec().into(),
[INFO] [stdout] 1183 +         result_types: result_types.to_vec(),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1183 -         result_types: result_types.to_vec().into(),
[INFO] [stdout] 1183 +         result_types: <tracked_alloc::Vec<value_type::ValueType> as Into<_>>::into(result_types.to_vec()),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/vm/jit/middle/rewrite/function.rs:1394:13
[INFO] [stdout]      |
[INFO] [stdout] 1394 |             "br_on_cast target type must be a reference".into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1394 -             "br_on_cast target type must be a reference".into(),
[INFO] [stdout] 1394 +             "br_on_cast target type must be a reference",
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1394 -             "br_on_cast target type must be a reference".into(),
[INFO] [stdout] 1394 +             <&str as Into<_>>::into("br_on_cast target type must be a reference"),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/vm/jit/middle/rewrite/function.rs:1824:29
[INFO] [stdout]      |
[INFO] [stdout] 1824 | ...                   "taken br_if with payload must have payload span".into(),
[INFO] [stdout]      |                       ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1824 -                             "taken br_if with payload must have payload span".into(),
[INFO] [stdout] 1824 +                             "taken br_if with payload must have payload span",
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1824 -                             "taken br_if with payload must have payload span".into(),
[INFO] [stdout] 1824 +                             <&str as Into<_>>::into("taken br_if with payload must have payload span"),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/vm/jit/middle/rewrite/function.rs:1833:25
[INFO] [stdout]      |
[INFO] [stdout] 1833 |                         "synthetic br_if then bridge requires canonical-only branch target".into(),
[INFO] [stdout]      |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1833 -                         "synthetic br_if then bridge requires canonical-only branch target".into(),
[INFO] [stdout] 1833 +                         "synthetic br_if then bridge requires canonical-only branch target",
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1833 -                         "synthetic br_if then bridge requires canonical-only branch target".into(),
[INFO] [stdout] 1833 +                         <&str as Into<_>>::into("synthetic br_if then bridge requires canonical-only branch target"),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/vm/jit/middle/rewrite/function.rs:2555:25
[INFO] [stdout]      |
[INFO] [stdout] 2555 |                         "taken branch target expects no live values but still has params".into(),
[INFO] [stdout]      |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2555 -                         "taken branch target expects no live values but still has params".into(),
[INFO] [stdout] 2555 +                         "taken branch target expects no live values but still has params",
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2555 -                         "taken branch target expects no live values but still has params".into(),
[INFO] [stdout] 2555 +                         <&str as Into<_>>::into("taken branch target expects no live values but still has params"),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/vm/jit/middle/rewrite/function.rs:2564:25
[INFO] [stdout]      |
[INFO] [stdout] 2564 |                         "taken branch payload width mismatch".into(),
[INFO] [stdout]      |                         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2564 -                         "taken branch payload width mismatch".into(),
[INFO] [stdout] 2564 +                         "taken branch payload width mismatch",
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2564 -                         "taken branch payload width mismatch".into(),
[INFO] [stdout] 2564 +                         <&str as Into<_>>::into("taken branch payload width mismatch"),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/vm/jit/middle/rewrite/function.rs:2593:44
[INFO] [stdout]      |
[INFO] [stdout] 2593 |         .ok_or_else(|| WasmError::internal("edge binding underflow".into()))?;
[INFO] [stdout]      |                                            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2593 -         .ok_or_else(|| WasmError::internal("edge binding underflow".into()))?;
[INFO] [stdout] 2593 +         .ok_or_else(|| WasmError::internal("edge binding underflow"))?;
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2593 -         .ok_or_else(|| WasmError::internal("edge binding underflow".into()))?;
[INFO] [stdout] 2593 +         .ok_or_else(|| WasmError::internal(<&str as Into<_>>::into("edge binding underflow")))?;
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]     --> src/vm/jit/middle/rewrite/function.rs:2616:21
[INFO] [stdout]      |
[INFO] [stdout] 2616 |                     "edge binding type refinement requires ref-compatible value".into(),
[INFO] [stdout]      |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 2616 -                     "edge binding type refinement requires ref-compatible value".into(),
[INFO] [stdout] 2616 +                     "edge binding type refinement requires ref-compatible value",
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 2616 -                     "edge binding type refinement requires ref-compatible value".into(),
[INFO] [stdout] 2616 +                     <&str as Into<_>>::into("edge binding type refinement requires ref-compatible value"),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `tracked_alloc::Vec<value_type::ValueType>`
[INFO] [stdout]    --> src/vm/jit/middle/rewrite/state.rs:162:13
[INFO] [stdout]     |
[INFO] [stdout] 162 |             full_stack_types.to_vec().into(),
[INFO] [stdout]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 162 -             full_stack_types.to_vec().into(),
[INFO] [stdout] 162 +             full_stack_types.to_vec(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 162 -             full_stack_types.to_vec().into(),
[INFO] [stdout] 162 +             <tracked_alloc::Vec<value_type::ValueType> as Into<_>>::into(full_stack_types.to_vec()),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `tracked_alloc::Vec<value_type::ValueType>`
[INFO] [stdout]    --> src/vm/jit/middle/rewrite/state.rs:163:13
[INFO] [stdout]     |
[INFO] [stdout] 163 |             entry.live_types.to_vec().into(),
[INFO] [stdout]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 163 -             entry.live_types.to_vec().into(),
[INFO] [stdout] 163 +             entry.live_types.to_vec(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 163 -             entry.live_types.to_vec().into(),
[INFO] [stdout] 163 +             <tracked_alloc::Vec<value_type::ValueType> as Into<_>>::into(entry.live_types.to_vec()),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `tracked_alloc::Vec<ir::SsaValue>`
[INFO] [stdout]    --> src/vm/jit/middle/rewrite/state.rs:171:19
[INFO] [stdout]     |
[INFO] [stdout] 171 |             live: params.to_vec().into(),
[INFO] [stdout]     |                   ^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 171 -             live: params.to_vec().into(),
[INFO] [stdout] 171 +             live: params.to_vec(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 171 -             live: params.to_vec().into(),
[INFO] [stdout] 171 +             live: <tracked_alloc::Vec<ir::SsaValue> as Into<_>>::into(params.to_vec()),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `tracked_alloc::Vec<ir::SsaValue>`
[INFO] [stdout]    --> src/vm/jit/middle/rewrite/state.rs:198:12
[INFO] [stdout]     |
[INFO] [stdout] 198 |         Ok(self.live[self.live.len() - count..].to_vec().into())
[INFO] [stdout]     |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 198 -         Ok(self.live[self.live.len() - count..].to_vec().into())
[INFO] [stdout] 198 +         Ok(self.live[self.live.len() - count..].to_vec())
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 198 -         Ok(self.live[self.live.len() - count..].to_vec().into())
[INFO] [stdout] 198 +         Ok(<tracked_alloc::Vec<ir::SsaValue> as Into<_>>::into(self.live[self.live.len() - count..].to_vec()))
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]   --> src/vm/jit/runtime/guard_pages.rs:61:17
[INFO] [stdout]    |
[INFO] [stdout] 61 |                 "guard-page memory: initial size exceeds reservation".into(),
[INFO] [stdout]    |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 61 -                 "guard-page memory: initial size exceeds reservation".into(),
[INFO] [stdout] 61 +                 "guard-page memory: initial size exceeds reservation",
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 61 -                 "guard-page memory: initial size exceeds reservation".into(),
[INFO] [stdout] 61 +                 <&str as Into<_>>::into("guard-page memory: initial size exceeds reservation"),
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `&str`
[INFO] [stdout]    --> src/vm/jit/runtime/guard_pages.rs:108:17
[INFO] [stdout]     |
[INFO] [stdout] 108 |                 "guard-page memory: grow exceeds reservation".into(),
[INFO] [stdout]     |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 108 -                 "guard-page memory: grow exceeds reservation".into(),
[INFO] [stdout] 108 +                 "guard-page memory: grow exceeds reservation",
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 108 -                 "guard-page memory: grow exceeds reservation".into(),
[INFO] [stdout] 108 +                 <&str as Into<_>>::into("guard-page memory: grow exceeds reservation"),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `tracked_alloc::Vec<value_type::ValueType>`
[INFO] [stdout]   --> src/vm/jit/wasm/context.rs:83:27
[INFO] [stdout]    |
[INFO] [stdout] 83 |                 .map(|ty| ty.results().to_vec().into())
[INFO] [stdout]    |                           ^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]    |
[INFO] [stdout] 83 -                 .map(|ty| ty.results().to_vec().into())
[INFO] [stdout] 83 +                 .map(|ty| ty.results().to_vec())
[INFO] [stdout]    |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 83 -                 .map(|ty| ty.results().to_vec().into())
[INFO] [stdout] 83 +                 .map(|ty| <tracked_alloc::Vec<value_type::ValueType> as Into<_>>::into(ty.results().to_vec()))
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `tracked_alloc::Vec<value_type::ValueType>`
[INFO] [stdout]    --> src/vm/jit/wasm/decode.rs:503:31
[INFO] [stdout]     |
[INFO] [stdout] 503 |                 result_types: compile.result_types.to_vec().into(),
[INFO] [stdout]     |                               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 503 -                 result_types: compile.result_types.to_vec().into(),
[INFO] [stdout] 503 +                 result_types: compile.result_types.to_vec(),
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 503 -                 result_types: compile.result_types.to_vec().into(),
[INFO] [stdout] 503 +                 result_types: <tracked_alloc::Vec<value_type::ValueType> as Into<_>>::into(compile.result_types.to_vec()),
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `tracked_alloc::Vec<value_type::ValueType>`
[INFO] [stdout]    --> src/vm/jit/wasm/decode.rs:641:13
[INFO] [stdout]     |
[INFO] [stdout] 641 |             self.type_stack[start..end].to_vec().into()
[INFO] [stdout]     |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 641 -             self.type_stack[start..end].to_vec().into()
[INFO] [stdout] 641 +             self.type_stack[start..end].to_vec()
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 641 -             self.type_stack[start..end].to_vec().into()
[INFO] [stdout] 641 +             <tracked_alloc::Vec<value_type::ValueType> as Into<_>>::into(self.type_stack[start..end].to_vec())
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `tracked_alloc::Vec<value_type::ValueType>`
[INFO] [stdout]    --> src/vm/jit/wasm/decode.rs:917:41
[INFO] [stdout]     |
[INFO] [stdout] 917 |                 .insert(idx.as_usize(), tys.to_vec().into());
[INFO] [stdout]     |                                         ^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]     |
[INFO] [stdout] 917 -                 .insert(idx.as_usize(), tys.to_vec().into());
[INFO] [stdout] 917 +                 .insert(idx.as_usize(), tys.to_vec());
[INFO] [stdout]     |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 917 -                 .insert(idx.as_usize(), tys.to_vec().into());
[INFO] [stdout] 917 +                 .insert(idx.as_usize(), <tracked_alloc::Vec<value_type::ValueType> as Into<_>>::into(tys.to_vec()));
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `tracked_alloc::Vec<value_type::ValueType>`
[INFO] [stdout]     --> src/vm/jit/wasm/decode.rs:1192:13
[INFO] [stdout]      |
[INFO] [stdout] 1192 |             self.compile.local_types.to_vec().into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1192 -             self.compile.local_types.to_vec().into(),
[INFO] [stdout] 1192 +             self.compile.local_types.to_vec(),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1192 -             self.compile.local_types.to_vec().into(),
[INFO] [stdout] 1192 +             <tracked_alloc::Vec<value_type::ValueType> as Into<_>>::into(self.compile.local_types.to_vec()),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `tracked_alloc::Vec<value_type::ValueType>`
[INFO] [stdout]     --> src/vm/jit/wasm/decode.rs:1193:13
[INFO] [stdout]      |
[INFO] [stdout] 1193 |             self.compile.result_types.to_vec().into(),
[INFO] [stdout]      |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]      |
[INFO] [stdout]      = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: consider removing the conversion call
[INFO] [stdout]      |
[INFO] [stdout] 1193 -             self.compile.result_types.to_vec().into(),
[INFO] [stdout] 1193 +             self.compile.result_types.to_vec(),
[INFO] [stdout]      |
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]      |
[INFO] [stdout] 1193 -             self.compile.result_types.to_vec().into(),
[INFO] [stdout] 1193 +             <tracked_alloc::Vec<value_type::ValueType> as Into<_>>::into(self.compile.result_types.to_vec()),
[INFO] [stdout]      |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `sf-nano-core` (lib test) due to 150 previous errors
[INFO] running `Command { std: "docker" "inspect" "778eba989f8adf1b6b797fe313d7e3115c4f627fe2a6751a995a645206829499", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "778eba989f8adf1b6b797fe313d7e3115c4f627fe2a6751a995a645206829499", kill_on_drop: false }`
[INFO] [stdout] 778eba989f8adf1b6b797fe313d7e3115c4f627fe2a6751a995a645206829499
