[INFO] cloning repository https://github.com/LegateJD/sm-encoders [INFO] running `Command { std: "git" "-c" "credential.helper=" "-c" "credential.helper=/workspace/cargo-home/bin/git-credential-null" "clone" "--bare" "https://github.com/LegateJD/sm-encoders" "/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2FLegateJD%2Fsm-encoders", kill_on_drop: false }` [INFO] [stderr] Cloning into bare repository '/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2FLegateJD%2Fsm-encoders'... [INFO] running `Command { std: "git" "rev-parse" "HEAD", kill_on_drop: false }` [INFO] [stdout] cab51b495ec1242594a79a650f768a006f799ee0 [INFO] checking LegateJD/sm-encoders against a5689b034ad287112f709693384a37f1377eb9cc for pr-129249-3 [INFO] running `Command { std: "git" "clone" "/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2FLegateJD%2Fsm-encoders" "/workspace/builds/worker-3-tc2/source", kill_on_drop: false }` [INFO] [stderr] Cloning into '/workspace/builds/worker-3-tc2/source'... [INFO] [stderr] done. [INFO] started tweaking git repo https://github.com/LegateJD/sm-encoders [INFO] finished tweaking git repo https://github.com/LegateJD/sm-encoders [INFO] tweaked toml for git repo https://github.com/LegateJD/sm-encoders written to /workspace/builds/worker-3-tc2/source/Cargo.toml [INFO] validating manifest of git repo https://github.com/LegateJD/sm-encoders 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 git repo https://github.com/LegateJD/sm-encoders 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] [stderr] warning: Cargo.toml: version requirement `0.9.34+deprecated` for dependency `serde_yaml` includes semver metadata which will be ignored, removing the metadata is recommended to avoid confusion [INFO] [stderr] warning: `ranis` (manifest) generated 1 warning [INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-3-tc2/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-3-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] 1e18755fbec9fd4ef68a80d47d0839070dfee48c5b8923eeebee6ad11e0b432d [INFO] running `Command { std: "docker" "start" "1e18755fbec9fd4ef68a80d47d0839070dfee48c5b8923eeebee6ad11e0b432d", kill_on_drop: false }` [INFO] running `Command { std: "docker" "inspect" "1e18755fbec9fd4ef68a80d47d0839070dfee48c5b8923eeebee6ad11e0b432d", 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" "1e18755fbec9fd4ef68a80d47d0839070dfee48c5b8923eeebee6ad11e0b432d" "/opt/rustwide/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }` [INFO] running `Command { std: "docker" "inspect" "1e18755fbec9fd4ef68a80d47d0839070dfee48c5b8923eeebee6ad11e0b432d", 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" "1e18755fbec9fd4ef68a80d47d0839070dfee48c5b8923eeebee6ad11e0b432d" "/opt/rustwide/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "check" "--frozen" "--all" "--all-targets" "--message-format=json", kill_on_drop: false }` [INFO] [stderr] warning: Cargo.toml: version requirement `0.9.34+deprecated` for dependency `serde_yaml` includes semver metadata which will be ignored, removing the metadata is recommended to avoid confusion [INFO] [stderr] warning: `ranis` (manifest) generated 1 warning [INFO] [stderr] Compiling serde_core v1.0.229 [INFO] [stderr] Compiling serde v1.0.229 [INFO] [stderr] Compiling byteorder v1.5.0 [INFO] [stderr] Compiling bitflags v2.13.1 [INFO] [stderr] Compiling syn v3.0.4 [INFO] [stderr] Compiling proc-macro-error-attr3 v3.1.0 [INFO] [stderr] Compiling syn v2.0.119 [INFO] [stderr] Checking clap_builder v4.6.6 [INFO] [stderr] Checking rand v0.10.2 [INFO] [stderr] Compiling proc-macro-error3 v3.1.0 [INFO] [stderr] Compiling serde_derive v1.0.229 [INFO] [stderr] Compiling clap_derive v4.6.4 [INFO] [stderr] Compiling thiserror-impl v2.0.20 [INFO] [stderr] Checking thiserror v2.0.20 [INFO] [stderr] Compiling dynasm v5.1.0 [INFO] [stderr] Checking clap v4.6.6 [INFO] [stderr] Checking serde_yaml v0.9.34+deprecated [INFO] [stderr] Checking dynasmrt v5.1.0 [INFO] [stderr] Checking ranis v0.1.0 (/opt/rustwide/workdir) [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/schema/x64.rs:52:22 [INFO] [stdout] | [INFO] [stdout] 52 | ; pop Rq(indexer_register_id) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: `#[deny(self_type_conversion)]` on by default [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 52 | ; pop Rq(>::into(indexer_register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/schema/x64.rs:66:45 [INFO] [stdout] | [INFO] [stdout] 66 | ... ; xor DWORD [Rq(indexer_register_id) + index], BigEndian::read_u32(&k) as i32 [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 66 | ; xor DWORD [Rq(>::into(indexer_register_id)) + index], BigEndian::read_u32(&k) as i32 [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/schema/x64.rs:71:45 [INFO] [stdout] | [INFO] [stdout] 71 | ... ; sub DWORD [Rq(indexer_register_id) + index], BigEndian::read_u32(&k) as i32 [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 71 | ; sub DWORD [Rq(>::into(indexer_register_id)) + index], BigEndian::read_u32(&k) as i32 [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/schema/x64.rs:76:45 [INFO] [stdout] | [INFO] [stdout] 76 | ... ; add DWORD [Rq(indexer_register_id) + index], BigEndian::read_u32(&k) as i32 [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 76 | ; add DWORD [Rq(>::into(indexer_register_id)) + index], BigEndian::read_u32(&k) as i32 [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/schema/x64.rs:81:45 [INFO] [stdout] | [INFO] [stdout] 81 | ... ; rol DWORD [Rq(indexer_register_id) + index], BigEndian::read_u32(&k) as i8 [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 81 | ; rol DWORD [Rq(>::into(indexer_register_id)) + index], BigEndian::read_u32(&k) as i8 [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/schema/x64.rs:86:45 [INFO] [stdout] | [INFO] [stdout] 86 | ... ; ror DWORD [Rq(indexer_register_id) + index], BigEndian::read_u32(&k) as i8 [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 86 | ; ror DWORD [Rq(>::into(indexer_register_id)) + index], BigEndian::read_u32(&k) as i8 [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/schema/x64.rs:93:41 [INFO] [stdout] | [INFO] [stdout] 93 | ; not DWORD [Rq(indexer_register_id) + index] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 93 | ; not DWORD [Rq(>::into(indexer_register_id)) + index] [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/schema/x64.rs:106:22 [INFO] [stdout] | [INFO] [stdout] 106 | ; jmp Rq(indexer_register_id) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 106 | ; jmp Rq(>::into(indexer_register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/sgn/x32.rs:50:22 [INFO] [stdout] | [INFO] [stdout] 50 | ; pop Rd(indexer_register_id) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 50 | ; pop Rd(>::into(indexer_register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/sgn/x32.rs:52:22 [INFO] [stdout] | [INFO] [stdout] 52 | ; mov Rb(seed_register_id), seed as i8 [INFO] [stdout] | ^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 52 | ; mov Rb(>::into(seed_register_id)), seed as i8 [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/sgn/x32.rs:54:65 [INFO] [stdout] | [INFO] [stdout] 54 | ; xor BYTE [Rd(indexer_register_id) + ecx + 19], Rb(seed_register_id) [INFO] [stdout] | ^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 54 | ; xor BYTE [Rd(indexer_register_id) + ecx + 19], Rb(>::into(seed_register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/sgn/x32.rs:54:28 [INFO] [stdout] | [INFO] [stdout] 54 | ; xor BYTE [Rd(indexer_register_id) + ecx + 19], Rb(seed_register_id) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 54 | ; xor BYTE [Rd(>::into(indexer_register_id)) + ecx + 19], Rb(seed_register_id) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/sgn/x32.rs:55:22 [INFO] [stdout] | [INFO] [stdout] 55 | ; add Rb(seed_register_id), BYTE [Rd(indexer_register_id) + ecx + 19] [INFO] [stdout] | ^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 55 | ; add Rb(>::into(seed_register_id)), BYTE [Rd(indexer_register_id) + ecx + 19] [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/sgn/x32.rs:55:50 [INFO] [stdout] | [INFO] [stdout] 55 | ; add Rb(seed_register_id), BYTE [Rd(indexer_register_id) + ecx + 19] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 55 | ; add Rb(seed_register_id), BYTE [Rd(>::into(indexer_register_id)) + ecx + 19] [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/sgn/x64.rs:47:22 [INFO] [stdout] | [INFO] [stdout] 47 | ; mov Rb(seed_register_id), seed as i8 [INFO] [stdout] | ^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 47 | ; mov Rb(>::into(seed_register_id)), seed as i8 [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/sgn/x64.rs:49:22 [INFO] [stdout] | [INFO] [stdout] 49 | ; lea Rq(indexer_register_id), [>data - 1] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 49 | ; lea Rq(>::into(indexer_register_id)), [>data - 1] [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/sgn/x64.rs:51:60 [INFO] [stdout] | [INFO] [stdout] 51 | ; xor BYTE [Rq(indexer_register_id) + rcx], Rb(seed_register_id) [INFO] [stdout] | ^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 51 | ; xor BYTE [Rq(indexer_register_id) + rcx], Rb(>::into(seed_register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/sgn/x64.rs:51:28 [INFO] [stdout] | [INFO] [stdout] 51 | ; xor BYTE [Rq(indexer_register_id) + rcx], Rb(seed_register_id) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 51 | ; xor BYTE [Rq(>::into(indexer_register_id)) + rcx], Rb(seed_register_id) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/sgn/x64.rs:52:22 [INFO] [stdout] | [INFO] [stdout] 52 | ; add Rb(seed_register_id), BYTE [Rq(indexer_register_id) + rcx] [INFO] [stdout] | ^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 52 | ; add Rb(>::into(seed_register_id)), BYTE [Rq(indexer_register_id) + rcx] [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/sgn/x64.rs:52:50 [INFO] [stdout] | [INFO] [stdout] 52 | ; add Rb(seed_register_id), BYTE [Rq(indexer_register_id) + rcx] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 52 | ; add Rb(seed_register_id), BYTE [Rq(>::into(indexer_register_id)) + rcx] [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:76:22 [INFO] [stdout] | [INFO] [stdout] 76 | ; rol Rq(register_id), 0 [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 76 | ; rol Rq(>::into(register_id)), 0 [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:84:22 [INFO] [stdout] | [INFO] [stdout] 84 | ; ror Rq(register_id), 0 [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 84 | ; ror Rq(>::into(register_id)), 0 [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:92:22 [INFO] [stdout] | [INFO] [stdout] 92 | ; shl Rq(register_id), 0 [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 92 | ; shl Rq(>::into(register_id)), 0 [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:100:22 [INFO] [stdout] | [INFO] [stdout] 100 | ; shr Rq(register_id), 0 [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 100 | ; shr Rq(>::into(register_id)), 0 [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:108:22 [INFO] [stdout] | [INFO] [stdout] 108 | ; rcl Rq(register_id), 0 [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 108 | ; rcl Rq(>::into(register_id)), 0 [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:116:22 [INFO] [stdout] | [INFO] [stdout] 116 | ; rcr Rq(register_id), 0 [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 116 | ; rcr Rq(>::into(register_id)), 0 [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:124:22 [INFO] [stdout] | [INFO] [stdout] 124 | ; sal Rq(register_id), 0 [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 124 | ; sal Rq(>::into(register_id)), 0 [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:132:22 [INFO] [stdout] | [INFO] [stdout] 132 | ; sar Rq(register_id), 0 [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 132 | ; sar Rq(>::into(register_id)), 0 [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:140:22 [INFO] [stdout] | [INFO] [stdout] 140 | ; xor Rq(register_id), 0 [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 140 | ; xor Rq(>::into(register_id)), 0 [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:148:22 [INFO] [stdout] | [INFO] [stdout] 148 | ; sub Rq(register_id), 0 [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 148 | ; sub Rq(>::into(register_id)), 0 [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:156:22 [INFO] [stdout] | [INFO] [stdout] 156 | ; add Rq(register_id), 0 [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 156 | ; add Rq(>::into(register_id)), 0 [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:164:39 [INFO] [stdout] | [INFO] [stdout] 164 | ; and Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 164 | ; and Rq(register_id), Rq(>::into(register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:164:22 [INFO] [stdout] | [INFO] [stdout] 164 | ; and Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 164 | ; and Rq(>::into(register_id)), Rq(register_id) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:172:38 [INFO] [stdout] | [INFO] [stdout] 172 | ; or Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 172 | ; or Rq(register_id), Rq(>::into(register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:172:21 [INFO] [stdout] | [INFO] [stdout] 172 | ; or Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 172 | ; or Rq(>::into(register_id)), Rq(register_id) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:180:38 [INFO] [stdout] | [INFO] [stdout] 180 | ; bt Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 180 | ; bt Rq(register_id), Rq(>::into(register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:180:21 [INFO] [stdout] | [INFO] [stdout] 180 | ; bt Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 180 | ; bt Rq(>::into(register_id)), Rq(register_id) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:188:22 [INFO] [stdout] | [INFO] [stdout] 188 | ; cmp Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 188 | ; cmp Rq(>::into(register_id)), Rq(register_id) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:188:39 [INFO] [stdout] | [INFO] [stdout] 188 | ; cmp Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 188 | ; cmp Rq(register_id), Rq(>::into(register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:196:39 [INFO] [stdout] | [INFO] [stdout] 196 | ; mov Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 196 | ; mov Rq(register_id), Rq(>::into(register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:196:22 [INFO] [stdout] | [INFO] [stdout] 196 | ; mov Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 196 | ; mov Rq(>::into(register_id)), Rq(register_id) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:204:23 [INFO] [stdout] | [INFO] [stdout] 204 | ; xchg Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 204 | ; xchg Rq(>::into(register_id)), Rq(register_id) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:204:40 [INFO] [stdout] | [INFO] [stdout] 204 | ; xchg Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 204 | ; xchg Rq(register_id), Rq(>::into(register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:212:40 [INFO] [stdout] | [INFO] [stdout] 212 | ; test Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 212 | ; test Rq(register_id), Rq(>::into(register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:212:23 [INFO] [stdout] | [INFO] [stdout] 212 | ; test Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 212 | ; test Rq(>::into(register_id)), Rq(register_id) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:220:24 [INFO] [stdout] | [INFO] [stdout] 220 | ; cmova Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 220 | ; cmova Rq(>::into(register_id)), Rq(register_id) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:220:41 [INFO] [stdout] | [INFO] [stdout] 220 | ; cmova Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 220 | ; cmova Rq(register_id), Rq(>::into(register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:228:24 [INFO] [stdout] | [INFO] [stdout] 228 | ; cmovb Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 228 | ; cmovb Rq(>::into(register_id)), Rq(register_id) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:228:41 [INFO] [stdout] | [INFO] [stdout] 228 | ; cmovb Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 228 | ; cmovb Rq(register_id), Rq(>::into(register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:236:24 [INFO] [stdout] | [INFO] [stdout] 236 | ; cmovc Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 236 | ; cmovc Rq(>::into(register_id)), Rq(register_id) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:236:41 [INFO] [stdout] | [INFO] [stdout] 236 | ; cmovc Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 236 | ; cmovc Rq(register_id), Rq(>::into(register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:244:24 [INFO] [stdout] | [INFO] [stdout] 244 | ; cmove Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 244 | ; cmove Rq(>::into(register_id)), Rq(register_id) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:244:41 [INFO] [stdout] | [INFO] [stdout] 244 | ; cmove Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 244 | ; cmove Rq(register_id), Rq(>::into(register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:252:24 [INFO] [stdout] | [INFO] [stdout] 252 | ; cmovg Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 252 | ; cmovg Rq(>::into(register_id)), Rq(register_id) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:252:41 [INFO] [stdout] | [INFO] [stdout] 252 | ; cmovg Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 252 | ; cmovg Rq(register_id), Rq(>::into(register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:260:24 [INFO] [stdout] | [INFO] [stdout] 260 | ; cmovl Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 260 | ; cmovl Rq(>::into(register_id)), Rq(register_id) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:260:41 [INFO] [stdout] | [INFO] [stdout] 260 | ; cmovl Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 260 | ; cmovl Rq(register_id), Rq(>::into(register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:268:24 [INFO] [stdout] | [INFO] [stdout] 268 | ; cmovo Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 268 | ; cmovo Rq(>::into(register_id)), Rq(register_id) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:268:41 [INFO] [stdout] | [INFO] [stdout] 268 | ; cmovo Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 268 | ; cmovo Rq(register_id), Rq(>::into(register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:276:24 [INFO] [stdout] | [INFO] [stdout] 276 | ; cmovp Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 276 | ; cmovp Rq(>::into(register_id)), Rq(register_id) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:276:41 [INFO] [stdout] | [INFO] [stdout] 276 | ; cmovp Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 276 | ; cmovp Rq(register_id), Rq(>::into(register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:284:24 [INFO] [stdout] | [INFO] [stdout] 284 | ; cmovs Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 284 | ; cmovs Rq(>::into(register_id)), Rq(register_id) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:284:41 [INFO] [stdout] | [INFO] [stdout] 284 | ; cmovs Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 284 | ; cmovs Rq(register_id), Rq(>::into(register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:292:24 [INFO] [stdout] | [INFO] [stdout] 292 | ; cmovz Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 292 | ; cmovz Rq(>::into(register_id)), Rq(register_id) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:292:41 [INFO] [stdout] | [INFO] [stdout] 292 | ; cmovz Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 292 | ; cmovz Rq(register_id), Rq(>::into(register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:300:25 [INFO] [stdout] | [INFO] [stdout] 300 | ; cmovae Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 300 | ; cmovae Rq(>::into(register_id)), Rq(register_id) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:300:42 [INFO] [stdout] | [INFO] [stdout] 300 | ; cmovae Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 300 | ; cmovae Rq(register_id), Rq(>::into(register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:308:25 [INFO] [stdout] | [INFO] [stdout] 308 | ; cmovge Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 308 | ; cmovge Rq(>::into(register_id)), Rq(register_id) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:308:42 [INFO] [stdout] | [INFO] [stdout] 308 | ; cmovge Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 308 | ; cmovge Rq(register_id), Rq(>::into(register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:316:25 [INFO] [stdout] | [INFO] [stdout] 316 | ; cmovle Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 316 | ; cmovle Rq(>::into(register_id)), Rq(register_id) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:316:42 [INFO] [stdout] | [INFO] [stdout] 316 | ; cmovle Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 316 | ; cmovle Rq(register_id), Rq(>::into(register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:324:25 [INFO] [stdout] | [INFO] [stdout] 324 | ; cmovna Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 324 | ; cmovna Rq(>::into(register_id)), Rq(register_id) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:324:42 [INFO] [stdout] | [INFO] [stdout] 324 | ; cmovna Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 324 | ; cmovna Rq(register_id), Rq(>::into(register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:332:25 [INFO] [stdout] | [INFO] [stdout] 332 | ; cmovnb Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 332 | ; cmovnb Rq(>::into(register_id)), Rq(register_id) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:332:42 [INFO] [stdout] | [INFO] [stdout] 332 | ; cmovnb Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 332 | ; cmovnb Rq(register_id), Rq(>::into(register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:340:25 [INFO] [stdout] | [INFO] [stdout] 340 | ; cmovnc Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 340 | ; cmovnc Rq(>::into(register_id)), Rq(register_id) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:340:42 [INFO] [stdout] | [INFO] [stdout] 340 | ; cmovnc Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 340 | ; cmovnc Rq(register_id), Rq(>::into(register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:348:25 [INFO] [stdout] | [INFO] [stdout] 348 | ; cmovne Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 348 | ; cmovne Rq(>::into(register_id)), Rq(register_id) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:348:42 [INFO] [stdout] | [INFO] [stdout] 348 | ; cmovne Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 348 | ; cmovne Rq(register_id), Rq(>::into(register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:356:25 [INFO] [stdout] | [INFO] [stdout] 356 | ; cmovng Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 356 | ; cmovng Rq(>::into(register_id)), Rq(register_id) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:356:42 [INFO] [stdout] | [INFO] [stdout] 356 | ; cmovng Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 356 | ; cmovng Rq(register_id), Rq(>::into(register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:364:25 [INFO] [stdout] | [INFO] [stdout] 364 | ; cmovnl Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 364 | ; cmovnl Rq(>::into(register_id)), Rq(register_id) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:364:42 [INFO] [stdout] | [INFO] [stdout] 364 | ; cmovnl Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 364 | ; cmovnl Rq(register_id), Rq(>::into(register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:372:25 [INFO] [stdout] | [INFO] [stdout] 372 | ; cmovno Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 372 | ; cmovno Rq(>::into(register_id)), Rq(register_id) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:372:42 [INFO] [stdout] | [INFO] [stdout] 372 | ; cmovno Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 372 | ; cmovno Rq(register_id), Rq(>::into(register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:380:25 [INFO] [stdout] | [INFO] [stdout] 380 | ; cmovnp Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 380 | ; cmovnp Rq(>::into(register_id)), Rq(register_id) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:380:42 [INFO] [stdout] | [INFO] [stdout] 380 | ; cmovnp Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 380 | ; cmovnp Rq(register_id), Rq(>::into(register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:388:25 [INFO] [stdout] | [INFO] [stdout] 388 | ; cmovns Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 388 | ; cmovns Rq(>::into(register_id)), Rq(register_id) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:388:42 [INFO] [stdout] | [INFO] [stdout] 388 | ; cmovns Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 388 | ; cmovns Rq(register_id), Rq(>::into(register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:396:25 [INFO] [stdout] | [INFO] [stdout] 396 | ; cmovnz Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 396 | ; cmovnz Rq(>::into(register_id)), Rq(register_id) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:396:42 [INFO] [stdout] | [INFO] [stdout] 396 | ; cmovnz Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 396 | ; cmovnz Rq(register_id), Rq(>::into(register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:404:25 [INFO] [stdout] | [INFO] [stdout] 404 | ; cmovpe Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 404 | ; cmovpe Rq(>::into(register_id)), Rq(register_id) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:404:42 [INFO] [stdout] | [INFO] [stdout] 404 | ; cmovpe Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 404 | ; cmovpe Rq(register_id), Rq(>::into(register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:412:25 [INFO] [stdout] | [INFO] [stdout] 412 | ; cmovpo Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 412 | ; cmovpo Rq(>::into(register_id)), Rq(register_id) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:412:42 [INFO] [stdout] | [INFO] [stdout] 412 | ; cmovpo Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 412 | ; cmovpo Rq(register_id), Rq(>::into(register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:420:25 [INFO] [stdout] | [INFO] [stdout] 420 | ; cmovbe Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 420 | ; cmovbe Rq(>::into(register_id)), Rq(register_id) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:420:42 [INFO] [stdout] | [INFO] [stdout] 420 | ; cmovbe Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 420 | ; cmovbe Rq(register_id), Rq(>::into(register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:428:26 [INFO] [stdout] | [INFO] [stdout] 428 | ; cmovnae Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 428 | ; cmovnae Rq(>::into(register_id)), Rq(register_id) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:428:43 [INFO] [stdout] | [INFO] [stdout] 428 | ; cmovnae Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 428 | ; cmovnae Rq(register_id), Rq(>::into(register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:436:26 [INFO] [stdout] | [INFO] [stdout] 436 | ; cmovnbe Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 436 | ; cmovnbe Rq(>::into(register_id)), Rq(register_id) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:436:43 [INFO] [stdout] | [INFO] [stdout] 436 | ; cmovnbe Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 436 | ; cmovnbe Rq(register_id), Rq(>::into(register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:444:26 [INFO] [stdout] | [INFO] [stdout] 444 | ; cmovnle Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 444 | ; cmovnle Rq(>::into(register_id)), Rq(register_id) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:444:43 [INFO] [stdout] | [INFO] [stdout] 444 | ; cmovnle Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 444 | ; cmovnle Rq(register_id), Rq(>::into(register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:452:26 [INFO] [stdout] | [INFO] [stdout] 452 | ; cmovnge Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 452 | ; cmovnge Rq(>::into(register_id)), Rq(register_id) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:452:43 [INFO] [stdout] | [INFO] [stdout] 452 | ; cmovnge Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 452 | ; cmovnge Rq(register_id), Rq(>::into(register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:473:22 [INFO] [stdout] | [INFO] [stdout] 473 | ; not Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 473 | ; not Rq(>::into(register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:479:22 [INFO] [stdout] | [INFO] [stdout] 479 | ; not Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 479 | ; not Rq(>::into(register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:487:22 [INFO] [stdout] | [INFO] [stdout] 487 | ; neg Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 487 | ; neg Rq(>::into(register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:493:22 [INFO] [stdout] | [INFO] [stdout] 493 | ; neg Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 493 | ; neg Rq(>::into(register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:501:22 [INFO] [stdout] | [INFO] [stdout] 501 | ; inc Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 501 | ; inc Rq(>::into(register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:507:22 [INFO] [stdout] | [INFO] [stdout] 507 | ; dec Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 507 | ; dec Rq(>::into(register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:515:22 [INFO] [stdout] | [INFO] [stdout] 515 | ; dec Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 515 | ; dec Rq(>::into(register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:521:22 [INFO] [stdout] | [INFO] [stdout] 521 | ; inc Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 521 | ; inc Rq(>::into(register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:530:22 [INFO] [stdout] | [INFO] [stdout] 530 | ; add Rq(register_id), random_byte as i32 [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 530 | ; add Rq(>::into(register_id)), random_byte as i32 [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:536:22 [INFO] [stdout] | [INFO] [stdout] 536 | ; sub Rq(register_id), random_byte as i32 [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 536 | ; sub Rq(>::into(register_id)), random_byte as i32 [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:545:22 [INFO] [stdout] | [INFO] [stdout] 545 | ; sub Rq(register_id), random_byte as i32 [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 545 | ; sub Rq(>::into(register_id)), random_byte as i32 [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:551:22 [INFO] [stdout] | [INFO] [stdout] 551 | ; add Rq(register_id), random_byte as i32 [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 551 | ; add Rq(>::into(register_id)), random_byte as i32 [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:560:22 [INFO] [stdout] | [INFO] [stdout] 560 | ; ror Rq(register_id), random_byte as i8 [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 560 | ; ror Rq(>::into(register_id)), random_byte as i8 [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:566:22 [INFO] [stdout] | [INFO] [stdout] 566 | ; rol Rq(register_id), random_byte as i8 [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 566 | ; rol Rq(>::into(register_id)), random_byte as i8 [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:575:22 [INFO] [stdout] | [INFO] [stdout] 575 | ; rol Rq(register_id), random_byte as i8 [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 575 | ; rol Rq(>::into(register_id)), random_byte as i8 [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:581:22 [INFO] [stdout] | [INFO] [stdout] 581 | ; ror Rq(register_id), random_byte as i8 [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 581 | ; ror Rq(>::into(register_id)), random_byte as i8 [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/xor_dynamic/x32.rs:72:22 [INFO] [stdout] | [INFO] [stdout] 72 | ; pop Rd(link_register_id) [INFO] [stdout] | ^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 72 | ; pop Rd(>::into(link_register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/xor_dynamic/x32.rs:73:23 [INFO] [stdout] | [INFO] [stdout] 73 | ; push Rd(link_register_id) [INFO] [stdout] | ^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 73 | ; push Rd(>::into(link_register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/xor_dynamic/x32.rs:74:22 [INFO] [stdout] | [INFO] [stdout] 74 | ; pop Rd(payload_indexer_register_id) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 74 | ; pop Rd(>::into(payload_indexer_register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/xor_dynamic/x32.rs:80:23 [INFO] [stdout] | [INFO] [stdout] 80 | ; push Rd(payload_indexer_register_id) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 80 | ; push Rd(>::into(payload_indexer_register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/xor_dynamic/x32.rs:81:22 [INFO] [stdout] | [INFO] [stdout] 81 | ; pop Rd(jmp_register_id) [INFO] [stdout] | ^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 81 | ; pop Rd(>::into(jmp_register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/xor_dynamic/x32.rs:83:23 [INFO] [stdout] | [INFO] [stdout] 83 | ; push Rd(link_register_id) [INFO] [stdout] | ^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 83 | ; push Rd(>::into(link_register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/xor_dynamic/x32.rs:84:22 [INFO] [stdout] | [INFO] [stdout] 84 | ; pop Rd(key_indexer_register_id) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 84 | ; pop Rd(>::into(key_indexer_register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/xor_dynamic/x32.rs:86:32 [INFO] [stdout] | [INFO] [stdout] 86 | ; mov al, BYTE [Rd(key_indexer_register_id)] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 86 | ; mov al, BYTE [Rd(>::into(key_indexer_register_id))] [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/xor_dynamic/x32.rs:87:28 [INFO] [stdout] | [INFO] [stdout] 87 | ; xor BYTE [Rd(payload_indexer_register_id)], al [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 87 | ; xor BYTE [Rd(>::into(payload_indexer_register_id))], al [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/xor_dynamic/x32.rs:88:22 [INFO] [stdout] | [INFO] [stdout] 88 | ; inc Rd(payload_indexer_register_id) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 88 | ; inc Rd(>::into(payload_indexer_register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/xor_dynamic/x32.rs:89:22 [INFO] [stdout] | [INFO] [stdout] 89 | ; inc Rd(key_indexer_register_id) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 89 | ; inc Rd(>::into(key_indexer_register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/xor_dynamic/x32.rs:90:28 [INFO] [stdout] | [INFO] [stdout] 90 | ; cmp WORD [Rd(payload_indexer_register_id)], 0x4242 [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 90 | ; cmp WORD [Rd(>::into(payload_indexer_register_id))], 0x4242 [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/xor_dynamic/x32.rs:92:28 [INFO] [stdout] | [INFO] [stdout] 92 | ; cmp BYTE [Rd(key_indexer_register_id)], 'A' as i8 [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 92 | ; cmp BYTE [Rd(>::into(key_indexer_register_id))], 'A' as i8 [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/xor_dynamic/x32.rs:96:22 [INFO] [stdout] | [INFO] [stdout] 96 | ; jmp Rd(jmp_register_id) [INFO] [stdout] | ^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 96 | ; jmp Rd(>::into(jmp_register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/xor_dynamic/x64.rs:82:22 [INFO] [stdout] | [INFO] [stdout] 82 | ; pop Rq(link_register_id) [INFO] [stdout] | ^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 82 | ; pop Rq(>::into(link_register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/xor_dynamic/x64.rs:83:23 [INFO] [stdout] | [INFO] [stdout] 83 | ; push Rq(link_register_id) [INFO] [stdout] | ^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 83 | ; push Rq(>::into(link_register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/xor_dynamic/x64.rs:91:22 [INFO] [stdout] | [INFO] [stdout] 91 | ; pop Rq(jmp_register_id) [INFO] [stdout] | ^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 91 | ; pop Rq(>::into(jmp_register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/xor_dynamic/x64.rs:93:23 [INFO] [stdout] | [INFO] [stdout] 93 | ; push Rq(link_register_id) [INFO] [stdout] | ^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 93 | ; push Rq(>::into(link_register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/xor_dynamic/x64.rs:94:22 [INFO] [stdout] | [INFO] [stdout] 94 | ; pop Rq(key_indexer_register_id) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 94 | ; pop Rq(>::into(key_indexer_register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/xor_dynamic/x64.rs:99:22 [INFO] [stdout] | [INFO] [stdout] 99 | ; inc Rq(key_indexer_register_id) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 99 | ; inc Rq(>::into(key_indexer_register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/xor_dynamic/x64.rs:106:22 [INFO] [stdout] | [INFO] [stdout] 106 | ; jmp Rq(jmp_register_id) [INFO] [stdout] | ^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 106 | ; jmp Rq(>::into(jmp_register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/xor_dynamic/x64.rs:130:22 [INFO] [stdout] | [INFO] [stdout] 130 | ; pop Rq(link_register_id) [INFO] [stdout] | ^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 130 | ; pop Rq(>::into(link_register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/xor_dynamic/x64.rs:131:23 [INFO] [stdout] | [INFO] [stdout] 131 | ; push Rq(link_register_id) [INFO] [stdout] | ^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 131 | ; push Rq(>::into(link_register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/xor_dynamic/x64.rs:139:22 [INFO] [stdout] | [INFO] [stdout] 139 | ; pop Rq(jmp_register_id) [INFO] [stdout] | ^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 139 | ; pop Rq(>::into(jmp_register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/xor_dynamic/x64.rs:141:23 [INFO] [stdout] | [INFO] [stdout] 141 | ; push Rq(link_register_id) [INFO] [stdout] | ^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 141 | ; push Rq(>::into(link_register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/xor_dynamic/x64.rs:142:22 [INFO] [stdout] | [INFO] [stdout] 142 | ; pop Rq(key_indexer_register_id) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 142 | ; pop Rq(>::into(key_indexer_register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/xor_dynamic/x64.rs:147:22 [INFO] [stdout] | [INFO] [stdout] 147 | ; inc Rq(key_indexer_register_id) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 147 | ; inc Rq(>::into(key_indexer_register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/xor_dynamic/x64.rs:154:22 [INFO] [stdout] | [INFO] [stdout] 154 | ; jmp Rq(jmp_register_id) [INFO] [stdout] | ^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 154 | ; jmp Rq(>::into(jmp_register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stderr] error: could not compile `ranis` (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: `u8` [INFO] [stdout] --> src/schema/x64.rs:52:22 [INFO] [stdout] | [INFO] [stdout] 52 | ; pop Rq(indexer_register_id) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: `#[deny(self_type_conversion)]` on by default [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 52 | ; pop Rq(>::into(indexer_register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/schema/x64.rs:66:45 [INFO] [stdout] | [INFO] [stdout] 66 | ... ; xor DWORD [Rq(indexer_register_id) + index], BigEndian::read_u32(&k) as i32 [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 66 | ; xor DWORD [Rq(>::into(indexer_register_id)) + index], BigEndian::read_u32(&k) as i32 [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/schema/x64.rs:71:45 [INFO] [stdout] | [INFO] [stdout] 71 | ... ; sub DWORD [Rq(indexer_register_id) + index], BigEndian::read_u32(&k) as i32 [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 71 | ; sub DWORD [Rq(>::into(indexer_register_id)) + index], BigEndian::read_u32(&k) as i32 [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/schema/x64.rs:76:45 [INFO] [stdout] | [INFO] [stdout] 76 | ... ; add DWORD [Rq(indexer_register_id) + index], BigEndian::read_u32(&k) as i32 [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 76 | ; add DWORD [Rq(>::into(indexer_register_id)) + index], BigEndian::read_u32(&k) as i32 [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/schema/x64.rs:81:45 [INFO] [stdout] | [INFO] [stdout] 81 | ... ; rol DWORD [Rq(indexer_register_id) + index], BigEndian::read_u32(&k) as i8 [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 81 | ; rol DWORD [Rq(>::into(indexer_register_id)) + index], BigEndian::read_u32(&k) as i8 [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/schema/x64.rs:86:45 [INFO] [stdout] | [INFO] [stdout] 86 | ... ; ror DWORD [Rq(indexer_register_id) + index], BigEndian::read_u32(&k) as i8 [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 86 | ; ror DWORD [Rq(>::into(indexer_register_id)) + index], BigEndian::read_u32(&k) as i8 [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/schema/x64.rs:93:41 [INFO] [stdout] | [INFO] [stdout] 93 | ; not DWORD [Rq(indexer_register_id) + index] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 93 | ; not DWORD [Rq(>::into(indexer_register_id)) + index] [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/schema/x64.rs:106:22 [INFO] [stdout] | [INFO] [stdout] 106 | ; jmp Rq(indexer_register_id) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 106 | ; jmp Rq(>::into(indexer_register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/sgn/x32.rs:50:22 [INFO] [stdout] | [INFO] [stdout] 50 | ; pop Rd(indexer_register_id) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 50 | ; pop Rd(>::into(indexer_register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/sgn/x32.rs:52:22 [INFO] [stdout] | [INFO] [stdout] 52 | ; mov Rb(seed_register_id), seed as i8 [INFO] [stdout] | ^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 52 | ; mov Rb(>::into(seed_register_id)), seed as i8 [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/sgn/x32.rs:54:65 [INFO] [stdout] | [INFO] [stdout] 54 | ; xor BYTE [Rd(indexer_register_id) + ecx + 19], Rb(seed_register_id) [INFO] [stdout] | ^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 54 | ; xor BYTE [Rd(indexer_register_id) + ecx + 19], Rb(>::into(seed_register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/sgn/x32.rs:54:28 [INFO] [stdout] | [INFO] [stdout] 54 | ; xor BYTE [Rd(indexer_register_id) + ecx + 19], Rb(seed_register_id) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 54 | ; xor BYTE [Rd(>::into(indexer_register_id)) + ecx + 19], Rb(seed_register_id) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/sgn/x32.rs:55:22 [INFO] [stdout] | [INFO] [stdout] 55 | ; add Rb(seed_register_id), BYTE [Rd(indexer_register_id) + ecx + 19] [INFO] [stdout] | ^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 55 | ; add Rb(>::into(seed_register_id)), BYTE [Rd(indexer_register_id) + ecx + 19] [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/sgn/x32.rs:55:50 [INFO] [stdout] | [INFO] [stdout] 55 | ; add Rb(seed_register_id), BYTE [Rd(indexer_register_id) + ecx + 19] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 55 | ; add Rb(seed_register_id), BYTE [Rd(>::into(indexer_register_id)) + ecx + 19] [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/sgn/x64.rs:47:22 [INFO] [stdout] | [INFO] [stdout] 47 | ; mov Rb(seed_register_id), seed as i8 [INFO] [stdout] | ^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 47 | ; mov Rb(>::into(seed_register_id)), seed as i8 [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/sgn/x64.rs:49:22 [INFO] [stdout] | [INFO] [stdout] 49 | ; lea Rq(indexer_register_id), [>data - 1] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 49 | ; lea Rq(>::into(indexer_register_id)), [>data - 1] [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/sgn/x64.rs:51:60 [INFO] [stdout] | [INFO] [stdout] 51 | ; xor BYTE [Rq(indexer_register_id) + rcx], Rb(seed_register_id) [INFO] [stdout] | ^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 51 | ; xor BYTE [Rq(indexer_register_id) + rcx], Rb(>::into(seed_register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/sgn/x64.rs:51:28 [INFO] [stdout] | [INFO] [stdout] 51 | ; xor BYTE [Rq(indexer_register_id) + rcx], Rb(seed_register_id) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 51 | ; xor BYTE [Rq(>::into(indexer_register_id)) + rcx], Rb(seed_register_id) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/sgn/x64.rs:52:22 [INFO] [stdout] | [INFO] [stdout] 52 | ; add Rb(seed_register_id), BYTE [Rq(indexer_register_id) + rcx] [INFO] [stdout] | ^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 52 | ; add Rb(>::into(seed_register_id)), BYTE [Rq(indexer_register_id) + rcx] [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/sgn/x64.rs:52:50 [INFO] [stdout] | [INFO] [stdout] 52 | ; add Rb(seed_register_id), BYTE [Rq(indexer_register_id) + rcx] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 52 | ; add Rb(seed_register_id), BYTE [Rq(>::into(indexer_register_id)) + rcx] [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:76:22 [INFO] [stdout] | [INFO] [stdout] 76 | ; rol Rq(register_id), 0 [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 76 | ; rol Rq(>::into(register_id)), 0 [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:84:22 [INFO] [stdout] | [INFO] [stdout] 84 | ; ror Rq(register_id), 0 [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 84 | ; ror Rq(>::into(register_id)), 0 [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:92:22 [INFO] [stdout] | [INFO] [stdout] 92 | ; shl Rq(register_id), 0 [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 92 | ; shl Rq(>::into(register_id)), 0 [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:100:22 [INFO] [stdout] | [INFO] [stdout] 100 | ; shr Rq(register_id), 0 [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 100 | ; shr Rq(>::into(register_id)), 0 [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:108:22 [INFO] [stdout] | [INFO] [stdout] 108 | ; rcl Rq(register_id), 0 [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 108 | ; rcl Rq(>::into(register_id)), 0 [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:116:22 [INFO] [stdout] | [INFO] [stdout] 116 | ; rcr Rq(register_id), 0 [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 116 | ; rcr Rq(>::into(register_id)), 0 [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:124:22 [INFO] [stdout] | [INFO] [stdout] 124 | ; sal Rq(register_id), 0 [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 124 | ; sal Rq(>::into(register_id)), 0 [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:132:22 [INFO] [stdout] | [INFO] [stdout] 132 | ; sar Rq(register_id), 0 [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 132 | ; sar Rq(>::into(register_id)), 0 [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:140:22 [INFO] [stdout] | [INFO] [stdout] 140 | ; xor Rq(register_id), 0 [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 140 | ; xor Rq(>::into(register_id)), 0 [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:148:22 [INFO] [stdout] | [INFO] [stdout] 148 | ; sub Rq(register_id), 0 [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 148 | ; sub Rq(>::into(register_id)), 0 [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:156:22 [INFO] [stdout] | [INFO] [stdout] 156 | ; add Rq(register_id), 0 [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 156 | ; add Rq(>::into(register_id)), 0 [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:164:39 [INFO] [stdout] | [INFO] [stdout] 164 | ; and Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 164 | ; and Rq(register_id), Rq(>::into(register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:164:22 [INFO] [stdout] | [INFO] [stdout] 164 | ; and Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 164 | ; and Rq(>::into(register_id)), Rq(register_id) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:172:38 [INFO] [stdout] | [INFO] [stdout] 172 | ; or Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 172 | ; or Rq(register_id), Rq(>::into(register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:172:21 [INFO] [stdout] | [INFO] [stdout] 172 | ; or Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 172 | ; or Rq(>::into(register_id)), Rq(register_id) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:180:38 [INFO] [stdout] | [INFO] [stdout] 180 | ; bt Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 180 | ; bt Rq(register_id), Rq(>::into(register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:180:21 [INFO] [stdout] | [INFO] [stdout] 180 | ; bt Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 180 | ; bt Rq(>::into(register_id)), Rq(register_id) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:188:22 [INFO] [stdout] | [INFO] [stdout] 188 | ; cmp Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 188 | ; cmp Rq(>::into(register_id)), Rq(register_id) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:188:39 [INFO] [stdout] | [INFO] [stdout] 188 | ; cmp Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 188 | ; cmp Rq(register_id), Rq(>::into(register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:196:39 [INFO] [stdout] | [INFO] [stdout] 196 | ; mov Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 196 | ; mov Rq(register_id), Rq(>::into(register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:196:22 [INFO] [stdout] | [INFO] [stdout] 196 | ; mov Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 196 | ; mov Rq(>::into(register_id)), Rq(register_id) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:204:23 [INFO] [stdout] | [INFO] [stdout] 204 | ; xchg Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 204 | ; xchg Rq(>::into(register_id)), Rq(register_id) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:204:40 [INFO] [stdout] | [INFO] [stdout] 204 | ; xchg Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 204 | ; xchg Rq(register_id), Rq(>::into(register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:212:40 [INFO] [stdout] | [INFO] [stdout] 212 | ; test Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 212 | ; test Rq(register_id), Rq(>::into(register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:212:23 [INFO] [stdout] | [INFO] [stdout] 212 | ; test Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 212 | ; test Rq(>::into(register_id)), Rq(register_id) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:220:24 [INFO] [stdout] | [INFO] [stdout] 220 | ; cmova Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 220 | ; cmova Rq(>::into(register_id)), Rq(register_id) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:220:41 [INFO] [stdout] | [INFO] [stdout] 220 | ; cmova Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 220 | ; cmova Rq(register_id), Rq(>::into(register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:228:24 [INFO] [stdout] | [INFO] [stdout] 228 | ; cmovb Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 228 | ; cmovb Rq(>::into(register_id)), Rq(register_id) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:228:41 [INFO] [stdout] | [INFO] [stdout] 228 | ; cmovb Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 228 | ; cmovb Rq(register_id), Rq(>::into(register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:236:24 [INFO] [stdout] | [INFO] [stdout] 236 | ; cmovc Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 236 | ; cmovc Rq(>::into(register_id)), Rq(register_id) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:236:41 [INFO] [stdout] | [INFO] [stdout] 236 | ; cmovc Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 236 | ; cmovc Rq(register_id), Rq(>::into(register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:244:24 [INFO] [stdout] | [INFO] [stdout] 244 | ; cmove Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 244 | ; cmove Rq(>::into(register_id)), Rq(register_id) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:244:41 [INFO] [stdout] | [INFO] [stdout] 244 | ; cmove Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 244 | ; cmove Rq(register_id), Rq(>::into(register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:252:24 [INFO] [stdout] | [INFO] [stdout] 252 | ; cmovg Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 252 | ; cmovg Rq(>::into(register_id)), Rq(register_id) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:252:41 [INFO] [stdout] | [INFO] [stdout] 252 | ; cmovg Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 252 | ; cmovg Rq(register_id), Rq(>::into(register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:260:24 [INFO] [stdout] | [INFO] [stdout] 260 | ; cmovl Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 260 | ; cmovl Rq(>::into(register_id)), Rq(register_id) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:260:41 [INFO] [stdout] | [INFO] [stdout] 260 | ; cmovl Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 260 | ; cmovl Rq(register_id), Rq(>::into(register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:268:24 [INFO] [stdout] | [INFO] [stdout] 268 | ; cmovo Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 268 | ; cmovo Rq(>::into(register_id)), Rq(register_id) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:268:41 [INFO] [stdout] | [INFO] [stdout] 268 | ; cmovo Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 268 | ; cmovo Rq(register_id), Rq(>::into(register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:276:24 [INFO] [stdout] | [INFO] [stdout] 276 | ; cmovp Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 276 | ; cmovp Rq(>::into(register_id)), Rq(register_id) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:276:41 [INFO] [stdout] | [INFO] [stdout] 276 | ; cmovp Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 276 | ; cmovp Rq(register_id), Rq(>::into(register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:284:24 [INFO] [stdout] | [INFO] [stdout] 284 | ; cmovs Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 284 | ; cmovs Rq(>::into(register_id)), Rq(register_id) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:284:41 [INFO] [stdout] | [INFO] [stdout] 284 | ; cmovs Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 284 | ; cmovs Rq(register_id), Rq(>::into(register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:292:24 [INFO] [stdout] | [INFO] [stdout] 292 | ; cmovz Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 292 | ; cmovz Rq(>::into(register_id)), Rq(register_id) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:292:41 [INFO] [stdout] | [INFO] [stdout] 292 | ; cmovz Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 292 | ; cmovz Rq(register_id), Rq(>::into(register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:300:25 [INFO] [stdout] | [INFO] [stdout] 300 | ; cmovae Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 300 | ; cmovae Rq(>::into(register_id)), Rq(register_id) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:300:42 [INFO] [stdout] | [INFO] [stdout] 300 | ; cmovae Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 300 | ; cmovae Rq(register_id), Rq(>::into(register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:308:25 [INFO] [stdout] | [INFO] [stdout] 308 | ; cmovge Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 308 | ; cmovge Rq(>::into(register_id)), Rq(register_id) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:308:42 [INFO] [stdout] | [INFO] [stdout] 308 | ; cmovge Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 308 | ; cmovge Rq(register_id), Rq(>::into(register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:316:25 [INFO] [stdout] | [INFO] [stdout] 316 | ; cmovle Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 316 | ; cmovle Rq(>::into(register_id)), Rq(register_id) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:316:42 [INFO] [stdout] | [INFO] [stdout] 316 | ; cmovle Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 316 | ; cmovle Rq(register_id), Rq(>::into(register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:324:25 [INFO] [stdout] | [INFO] [stdout] 324 | ; cmovna Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 324 | ; cmovna Rq(>::into(register_id)), Rq(register_id) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:324:42 [INFO] [stdout] | [INFO] [stdout] 324 | ; cmovna Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 324 | ; cmovna Rq(register_id), Rq(>::into(register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:332:25 [INFO] [stdout] | [INFO] [stdout] 332 | ; cmovnb Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 332 | ; cmovnb Rq(>::into(register_id)), Rq(register_id) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:332:42 [INFO] [stdout] | [INFO] [stdout] 332 | ; cmovnb Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 332 | ; cmovnb Rq(register_id), Rq(>::into(register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:340:25 [INFO] [stdout] | [INFO] [stdout] 340 | ; cmovnc Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 340 | ; cmovnc Rq(>::into(register_id)), Rq(register_id) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:340:42 [INFO] [stdout] | [INFO] [stdout] 340 | ; cmovnc Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 340 | ; cmovnc Rq(register_id), Rq(>::into(register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:348:25 [INFO] [stdout] | [INFO] [stdout] 348 | ; cmovne Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 348 | ; cmovne Rq(>::into(register_id)), Rq(register_id) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:348:42 [INFO] [stdout] | [INFO] [stdout] 348 | ; cmovne Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 348 | ; cmovne Rq(register_id), Rq(>::into(register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:356:25 [INFO] [stdout] | [INFO] [stdout] 356 | ; cmovng Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 356 | ; cmovng Rq(>::into(register_id)), Rq(register_id) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:356:42 [INFO] [stdout] | [INFO] [stdout] 356 | ; cmovng Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 356 | ; cmovng Rq(register_id), Rq(>::into(register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:364:25 [INFO] [stdout] | [INFO] [stdout] 364 | ; cmovnl Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 364 | ; cmovnl Rq(>::into(register_id)), Rq(register_id) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:364:42 [INFO] [stdout] | [INFO] [stdout] 364 | ; cmovnl Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 364 | ; cmovnl Rq(register_id), Rq(>::into(register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:372:25 [INFO] [stdout] | [INFO] [stdout] 372 | ; cmovno Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 372 | ; cmovno Rq(>::into(register_id)), Rq(register_id) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:372:42 [INFO] [stdout] | [INFO] [stdout] 372 | ; cmovno Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 372 | ; cmovno Rq(register_id), Rq(>::into(register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:380:25 [INFO] [stdout] | [INFO] [stdout] 380 | ; cmovnp Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 380 | ; cmovnp Rq(>::into(register_id)), Rq(register_id) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:380:42 [INFO] [stdout] | [INFO] [stdout] 380 | ; cmovnp Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 380 | ; cmovnp Rq(register_id), Rq(>::into(register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:388:25 [INFO] [stdout] | [INFO] [stdout] 388 | ; cmovns Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 388 | ; cmovns Rq(>::into(register_id)), Rq(register_id) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:388:42 [INFO] [stdout] | [INFO] [stdout] 388 | ; cmovns Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 388 | ; cmovns Rq(register_id), Rq(>::into(register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:396:25 [INFO] [stdout] | [INFO] [stdout] 396 | ; cmovnz Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 396 | ; cmovnz Rq(>::into(register_id)), Rq(register_id) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:396:42 [INFO] [stdout] | [INFO] [stdout] 396 | ; cmovnz Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 396 | ; cmovnz Rq(register_id), Rq(>::into(register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:404:25 [INFO] [stdout] | [INFO] [stdout] 404 | ; cmovpe Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 404 | ; cmovpe Rq(>::into(register_id)), Rq(register_id) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:404:42 [INFO] [stdout] | [INFO] [stdout] 404 | ; cmovpe Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 404 | ; cmovpe Rq(register_id), Rq(>::into(register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:412:25 [INFO] [stdout] | [INFO] [stdout] 412 | ; cmovpo Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 412 | ; cmovpo Rq(>::into(register_id)), Rq(register_id) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:412:42 [INFO] [stdout] | [INFO] [stdout] 412 | ; cmovpo Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 412 | ; cmovpo Rq(register_id), Rq(>::into(register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:420:25 [INFO] [stdout] | [INFO] [stdout] 420 | ; cmovbe Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 420 | ; cmovbe Rq(>::into(register_id)), Rq(register_id) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:420:42 [INFO] [stdout] | [INFO] [stdout] 420 | ; cmovbe Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 420 | ; cmovbe Rq(register_id), Rq(>::into(register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:428:26 [INFO] [stdout] | [INFO] [stdout] 428 | ; cmovnae Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 428 | ; cmovnae Rq(>::into(register_id)), Rq(register_id) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:428:43 [INFO] [stdout] | [INFO] [stdout] 428 | ; cmovnae Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 428 | ; cmovnae Rq(register_id), Rq(>::into(register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:436:26 [INFO] [stdout] | [INFO] [stdout] 436 | ; cmovnbe Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 436 | ; cmovnbe Rq(>::into(register_id)), Rq(register_id) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:436:43 [INFO] [stdout] | [INFO] [stdout] 436 | ; cmovnbe Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 436 | ; cmovnbe Rq(register_id), Rq(>::into(register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:444:26 [INFO] [stdout] | [INFO] [stdout] 444 | ; cmovnle Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 444 | ; cmovnle Rq(>::into(register_id)), Rq(register_id) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:444:43 [INFO] [stdout] | [INFO] [stdout] 444 | ; cmovnle Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 444 | ; cmovnle Rq(register_id), Rq(>::into(register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:452:26 [INFO] [stdout] | [INFO] [stdout] 452 | ; cmovnge Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 452 | ; cmovnge Rq(>::into(register_id)), Rq(register_id) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:452:43 [INFO] [stdout] | [INFO] [stdout] 452 | ; cmovnge Rq(register_id), Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 452 | ; cmovnge Rq(register_id), Rq(>::into(register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:473:22 [INFO] [stdout] | [INFO] [stdout] 473 | ; not Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 473 | ; not Rq(>::into(register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:479:22 [INFO] [stdout] | [INFO] [stdout] 479 | ; not Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 479 | ; not Rq(>::into(register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:487:22 [INFO] [stdout] | [INFO] [stdout] 487 | ; neg Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 487 | ; neg Rq(>::into(register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:493:22 [INFO] [stdout] | [INFO] [stdout] 493 | ; neg Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 493 | ; neg Rq(>::into(register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:501:22 [INFO] [stdout] | [INFO] [stdout] 501 | ; inc Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 501 | ; inc Rq(>::into(register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:507:22 [INFO] [stdout] | [INFO] [stdout] 507 | ; dec Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 507 | ; dec Rq(>::into(register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:515:22 [INFO] [stdout] | [INFO] [stdout] 515 | ; dec Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 515 | ; dec Rq(>::into(register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:521:22 [INFO] [stdout] | [INFO] [stdout] 521 | ; inc Rq(register_id) [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 521 | ; inc Rq(>::into(register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:530:22 [INFO] [stdout] | [INFO] [stdout] 530 | ; add Rq(register_id), random_byte as i32 [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 530 | ; add Rq(>::into(register_id)), random_byte as i32 [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:536:22 [INFO] [stdout] | [INFO] [stdout] 536 | ; sub Rq(register_id), random_byte as i32 [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 536 | ; sub Rq(>::into(register_id)), random_byte as i32 [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:545:22 [INFO] [stdout] | [INFO] [stdout] 545 | ; sub Rq(register_id), random_byte as i32 [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 545 | ; sub Rq(>::into(register_id)), random_byte as i32 [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:551:22 [INFO] [stdout] | [INFO] [stdout] 551 | ; add Rq(register_id), random_byte as i32 [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 551 | ; add Rq(>::into(register_id)), random_byte as i32 [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:560:22 [INFO] [stdout] | [INFO] [stdout] 560 | ; ror Rq(register_id), random_byte as i8 [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 560 | ; ror Rq(>::into(register_id)), random_byte as i8 [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:566:22 [INFO] [stdout] | [INFO] [stdout] 566 | ; rol Rq(register_id), random_byte as i8 [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 566 | ; rol Rq(>::into(register_id)), random_byte as i8 [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:575:22 [INFO] [stdout] | [INFO] [stdout] 575 | ; rol Rq(register_id), random_byte as i8 [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 575 | ; rol Rq(>::into(register_id)), random_byte as i8 [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/x64_arch/garbage.rs:581:22 [INFO] [stdout] | [INFO] [stdout] 581 | ; ror Rq(register_id), random_byte as i8 [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 581 | ; ror Rq(>::into(register_id)), random_byte as i8 [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/xor_dynamic/x32.rs:72:22 [INFO] [stdout] | [INFO] [stdout] 72 | ; pop Rd(link_register_id) [INFO] [stdout] | ^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 72 | ; pop Rd(>::into(link_register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/xor_dynamic/x32.rs:73:23 [INFO] [stdout] | [INFO] [stdout] 73 | ; push Rd(link_register_id) [INFO] [stdout] | ^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 73 | ; push Rd(>::into(link_register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/xor_dynamic/x32.rs:74:22 [INFO] [stdout] | [INFO] [stdout] 74 | ; pop Rd(payload_indexer_register_id) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 74 | ; pop Rd(>::into(payload_indexer_register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/xor_dynamic/x32.rs:80:23 [INFO] [stdout] | [INFO] [stdout] 80 | ; push Rd(payload_indexer_register_id) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 80 | ; push Rd(>::into(payload_indexer_register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/xor_dynamic/x32.rs:81:22 [INFO] [stdout] | [INFO] [stdout] 81 | ; pop Rd(jmp_register_id) [INFO] [stdout] | ^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 81 | ; pop Rd(>::into(jmp_register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/xor_dynamic/x32.rs:83:23 [INFO] [stdout] | [INFO] [stdout] 83 | ; push Rd(link_register_id) [INFO] [stdout] | ^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 83 | ; push Rd(>::into(link_register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/xor_dynamic/x32.rs:84:22 [INFO] [stdout] | [INFO] [stdout] 84 | ; pop Rd(key_indexer_register_id) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 84 | ; pop Rd(>::into(key_indexer_register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/xor_dynamic/x32.rs:86:32 [INFO] [stdout] | [INFO] [stdout] 86 | ; mov al, BYTE [Rd(key_indexer_register_id)] [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 86 | ; mov al, BYTE [Rd(>::into(key_indexer_register_id))] [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/xor_dynamic/x32.rs:87:28 [INFO] [stdout] | [INFO] [stdout] 87 | ; xor BYTE [Rd(payload_indexer_register_id)], al [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 87 | ; xor BYTE [Rd(>::into(payload_indexer_register_id))], al [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/xor_dynamic/x32.rs:88:22 [INFO] [stdout] | [INFO] [stdout] 88 | ; inc Rd(payload_indexer_register_id) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 88 | ; inc Rd(>::into(payload_indexer_register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/xor_dynamic/x32.rs:89:22 [INFO] [stdout] | [INFO] [stdout] 89 | ; inc Rd(key_indexer_register_id) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 89 | ; inc Rd(>::into(key_indexer_register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/xor_dynamic/x32.rs:90:28 [INFO] [stdout] | [INFO] [stdout] 90 | ; cmp WORD [Rd(payload_indexer_register_id)], 0x4242 [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 90 | ; cmp WORD [Rd(>::into(payload_indexer_register_id))], 0x4242 [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/xor_dynamic/x32.rs:92:28 [INFO] [stdout] | [INFO] [stdout] 92 | ; cmp BYTE [Rd(key_indexer_register_id)], 'A' as i8 [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 92 | ; cmp BYTE [Rd(>::into(key_indexer_register_id))], 'A' as i8 [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/xor_dynamic/x32.rs:96:22 [INFO] [stdout] | [INFO] [stdout] 96 | ; jmp Rd(jmp_register_id) [INFO] [stdout] | ^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 96 | ; jmp Rd(>::into(jmp_register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/xor_dynamic/x64.rs:82:22 [INFO] [stdout] | [INFO] [stdout] 82 | ; pop Rq(link_register_id) [INFO] [stdout] | ^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 82 | ; pop Rq(>::into(link_register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/xor_dynamic/x64.rs:83:23 [INFO] [stdout] | [INFO] [stdout] 83 | ; push Rq(link_register_id) [INFO] [stdout] | ^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 83 | ; push Rq(>::into(link_register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/xor_dynamic/x64.rs:91:22 [INFO] [stdout] | [INFO] [stdout] 91 | ; pop Rq(jmp_register_id) [INFO] [stdout] | ^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 91 | ; pop Rq(>::into(jmp_register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/xor_dynamic/x64.rs:93:23 [INFO] [stdout] | [INFO] [stdout] 93 | ; push Rq(link_register_id) [INFO] [stdout] | ^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 93 | ; push Rq(>::into(link_register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/xor_dynamic/x64.rs:94:22 [INFO] [stdout] | [INFO] [stdout] 94 | ; pop Rq(key_indexer_register_id) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 94 | ; pop Rq(>::into(key_indexer_register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/xor_dynamic/x64.rs:99:22 [INFO] [stdout] | [INFO] [stdout] 99 | ; inc Rq(key_indexer_register_id) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 99 | ; inc Rq(>::into(key_indexer_register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/xor_dynamic/x64.rs:106:22 [INFO] [stdout] | [INFO] [stdout] 106 | ; jmp Rq(jmp_register_id) [INFO] [stdout] | ^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 106 | ; jmp Rq(>::into(jmp_register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/xor_dynamic/x64.rs:130:22 [INFO] [stdout] | [INFO] [stdout] 130 | ; pop Rq(link_register_id) [INFO] [stdout] | ^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 130 | ; pop Rq(>::into(link_register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/xor_dynamic/x64.rs:131:23 [INFO] [stdout] | [INFO] [stdout] 131 | ; push Rq(link_register_id) [INFO] [stdout] | ^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 131 | ; push Rq(>::into(link_register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/xor_dynamic/x64.rs:139:22 [INFO] [stdout] | [INFO] [stdout] 139 | ; pop Rq(jmp_register_id) [INFO] [stdout] | ^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 139 | ; pop Rq(>::into(jmp_register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/xor_dynamic/x64.rs:141:23 [INFO] [stdout] | [INFO] [stdout] 141 | ; push Rq(link_register_id) [INFO] [stdout] | ^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 141 | ; push Rq(>::into(link_register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/xor_dynamic/x64.rs:142:22 [INFO] [stdout] | [INFO] [stdout] 142 | ; pop Rq(key_indexer_register_id) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 142 | ; pop Rq(>::into(key_indexer_register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/xor_dynamic/x64.rs:147:22 [INFO] [stdout] | [INFO] [stdout] 147 | ; inc Rq(key_indexer_register_id) [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 147 | ; inc Rq(>::into(key_indexer_register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/xor_dynamic/x64.rs:154:22 [INFO] [stdout] | [INFO] [stdout] 154 | ; jmp Rq(jmp_register_id) [INFO] [stdout] | ^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 154 | ; jmp Rq(>::into(jmp_register_id)) [INFO] [stdout] | ++++++++++++++++++++++ + [INFO] [stdout] [INFO] [stdout] [INFO] [stderr] error: could not compile `ranis` (lib test) due to 149 previous errors [INFO] running `Command { std: "docker" "inspect" "1e18755fbec9fd4ef68a80d47d0839070dfee48c5b8923eeebee6ad11e0b432d", kill_on_drop: false }` [INFO] running `Command { std: "docker" "rm" "-f" "1e18755fbec9fd4ef68a80d47d0839070dfee48c5b8923eeebee6ad11e0b432d", kill_on_drop: false }` [INFO] [stdout] 1e18755fbec9fd4ef68a80d47d0839070dfee48c5b8923eeebee6ad11e0b432d