[INFO] cloning repository https://github.com/Stausee1337/emulator [INFO] running `Command { std: "git" "-c" "credential.helper=" "-c" "credential.helper=/workspace/cargo-home/bin/git-credential-null" "clone" "--bare" "https://github.com/Stausee1337/emulator" "/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2FStausee1337%2Femulator", kill_on_drop: false }` [INFO] [stderr] Cloning into bare repository '/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2FStausee1337%2Femulator'... [INFO] running `Command { std: "git" "rev-parse" "HEAD", kill_on_drop: false }` [INFO] [stdout] de75d84557af11d4fbaf61101572b7c22791bf96 [INFO] checking Stausee1337/emulator against a5689b034ad287112f709693384a37f1377eb9cc for pr-129249-3 [INFO] running `Command { std: "git" "clone" "/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2FStausee1337%2Femulator" "/workspace/builds/worker-0-tc2/source", kill_on_drop: false }` [INFO] [stderr] Cloning into '/workspace/builds/worker-0-tc2/source'... [INFO] [stderr] done. [INFO] started tweaking git repo https://github.com/Stausee1337/emulator [INFO] finished tweaking git repo https://github.com/Stausee1337/emulator [INFO] tweaked toml for git repo https://github.com/Stausee1337/emulator written to /workspace/builds/worker-0-tc2/source/Cargo.toml [INFO] validating manifest of git repo https://github.com/Stausee1337/emulator 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/Stausee1337/emulator already has a lockfile, it will not be regenerated [INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "fetch" "--manifest-path" "Cargo.toml", kill_on_drop: false }` [INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-0-tc2/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-0-tc2/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/cargo-home:/opt/rustwide/cargo-home:ro,Z" "-v" "/var/lib/crater-agent-workspace/rustup-home:/opt/rustwide/rustup-home:ro,Z" "-m" "1610612736" "--network" "none" "ghcr.io/rust-lang/crates-build-env/linux@sha256:77db811e55d90add9212f6832c23229e3de5f1c1f9905e8cb07319ea15df73ac" "sleep" "infinity", kill_on_drop: false }` [INFO] [stdout] 2d245efea16870ed17c491527e37418b03b33ecbe698777624859cd29062f668 [INFO] running `Command { std: "docker" "start" "2d245efea16870ed17c491527e37418b03b33ecbe698777624859cd29062f668", kill_on_drop: false }` [INFO] running `Command { std: "docker" "inspect" "2d245efea16870ed17c491527e37418b03b33ecbe698777624859cd29062f668", 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" "2d245efea16870ed17c491527e37418b03b33ecbe698777624859cd29062f668" "/opt/rustwide/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }` [INFO] running `Command { std: "docker" "inspect" "2d245efea16870ed17c491527e37418b03b33ecbe698777624859cd29062f668", 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" "2d245efea16870ed17c491527e37418b03b33ecbe698777624859cd29062f668" "/opt/rustwide/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "check" "--frozen" "--all" "--all-targets" "--message-format=json", kill_on_drop: false }` [INFO] [stderr] Compiling syn v2.0.117 [INFO] [stderr] Checking bytemuck v1.25.0 [INFO] [stderr] Compiling emulator_macros v0.1.0 (/opt/rustwide/workdir/emulator_macros) [INFO] [stderr] Checking emulator v0.1.0 (/opt/rustwide/workdir) [INFO] [stdout] warning: unused import: `bitflags::bitflags` [INFO] [stdout] --> src/disasm/instruction.rs:3:5 [INFO] [stdout] | [INFO] [stdout] 3 | use bitflags::bitflags; [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: `#[warn(unused_imports)]` (part of `#[warn(unused)]`) on by default [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `thread::sleep` and `time::Duration` [INFO] [stdout] --> src/cpu.rs:1:65 [INFO] [stdout] | [INFO] [stdout] 1 | use std::{fmt::Write, io::{Read, Seek}, ops::{Deref, DerefMut}, thread::sleep, time::Duration}; [INFO] [stdout] | ^^^^^^^^^^^^^ ^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: the feature `never_type` has been stable since 1.100.0 and no longer requires an attribute to enable [INFO] [stdout] --> src/main.rs:1:12 [INFO] [stdout] | [INFO] [stdout] 1 | #![feature(never_type)] [INFO] [stdout] | ^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: `#[warn(stable_features)]` on by default [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused import: `bitflags::bitflags` [INFO] [stdout] --> src/disasm/instruction.rs:3:5 [INFO] [stdout] | [INFO] [stdout] 3 | use bitflags::bitflags; [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: `#[warn(unused_imports)]` (part of `#[warn(unused)]`) on by default [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused imports: `thread::sleep` and `time::Duration` [INFO] [stdout] --> src/cpu.rs:1:65 [INFO] [stdout] | [INFO] [stdout] 1 | use std::{fmt::Write, io::{Read, Seek}, ops::{Deref, DerefMut}, thread::sleep, time::Duration}; [INFO] [stdout] | ^^^^^^^^^^^^^ ^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: the feature `never_type` has been stable since 1.100.0 and no longer requires an attribute to enable [INFO] [stdout] --> src/main.rs:1:12 [INFO] [stdout] | [INFO] [stdout] 1 | #![feature(never_type)] [INFO] [stdout] | ^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: `#[warn(stable_features)]` on by default [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: struct `IndependentSize` is never constructed [INFO] [stdout] --> src/disasm/instruction.rs:214:12 [INFO] [stdout] | [INFO] [stdout] 214 | pub struct IndependentSize; [INFO] [stdout] | ^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: `#[warn(dead_code)]` (part of `#[warn(unused)]`) on by default [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:262:44 [INFO] [stdout] | [INFO] [stdout] 262 | instructions8::Add { dest: modrm.effective().into(), src: modrm.register().into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: `#[deny(self_type_conversion)]` on by default [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 262 - instructions8::Add { dest: modrm.effective().into(), src: modrm.register().into() }.into(), [INFO] [stdout] 262 + instructions8::Add { dest: modrm.effective(), src: modrm.register().into() }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 262 - instructions8::Add { dest: modrm.effective().into(), src: modrm.register().into() }.into(), [INFO] [stdout] 262 + instructions8::Add { dest: as Into<_>>::into(modrm.effective()), src: modrm.register().into() }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:264:45 [INFO] [stdout] | [INFO] [stdout] 264 | instructions16::Add { dest: modrm.effective().into(), src: modrm.register().into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 264 - instructions16::Add { dest: modrm.effective().into(), src: modrm.register().into() }.into(), [INFO] [stdout] 264 + instructions16::Add { dest: modrm.effective(), src: modrm.register().into() }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 264 - instructions16::Add { dest: modrm.effective().into(), src: modrm.register().into() }.into(), [INFO] [stdout] 264 + instructions16::Add { dest: as Into<_>>::into(modrm.effective()), src: modrm.register().into() }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:266:44 [INFO] [stdout] | [INFO] [stdout] 266 | instructions8::Add { dest: modrm.register().into(), src: modrm.effective().into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 266 - instructions8::Add { dest: modrm.register().into(), src: modrm.effective().into() }.into(), [INFO] [stdout] 266 + instructions8::Add { dest: modrm.register(), src: modrm.effective().into() }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 266 - instructions8::Add { dest: modrm.register().into(), src: modrm.effective().into() }.into(), [INFO] [stdout] 266 + instructions8::Add { dest: as Into<_>>::into(modrm.register()), src: modrm.effective().into() }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:268:45 [INFO] [stdout] | [INFO] [stdout] 268 | instructions16::Add { dest: modrm.register().into(), src: modrm.effective().into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 268 - instructions16::Add { dest: modrm.register().into(), src: modrm.effective().into() }.into(), [INFO] [stdout] 268 + instructions16::Add { dest: modrm.register(), src: modrm.effective().into() }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 268 - instructions16::Add { dest: modrm.register().into(), src: modrm.effective().into() }.into(), [INFO] [stdout] 268 + instructions16::Add { dest: as Into<_>>::into(modrm.register()), src: modrm.effective().into() }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:278:43 [INFO] [stdout] | [INFO] [stdout] 278 | instructions8::Or { dest: modrm.effective().into(), src: modrm.register().into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 278 - instructions8::Or { dest: modrm.effective().into(), src: modrm.register().into() }.into(), [INFO] [stdout] 278 + instructions8::Or { dest: modrm.effective(), src: modrm.register().into() }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 278 - instructions8::Or { dest: modrm.effective().into(), src: modrm.register().into() }.into(), [INFO] [stdout] 278 + instructions8::Or { dest: as Into<_>>::into(modrm.effective()), src: modrm.register().into() }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:280:44 [INFO] [stdout] | [INFO] [stdout] 280 | instructions16::Or { dest: modrm.effective().into(), src: modrm.register().into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 280 - instructions16::Or { dest: modrm.effective().into(), src: modrm.register().into() }.into(), [INFO] [stdout] 280 + instructions16::Or { dest: modrm.effective(), src: modrm.register().into() }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 280 - instructions16::Or { dest: modrm.effective().into(), src: modrm.register().into() }.into(), [INFO] [stdout] 280 + instructions16::Or { dest: as Into<_>>::into(modrm.effective()), src: modrm.register().into() }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:282:43 [INFO] [stdout] | [INFO] [stdout] 282 | instructions8::Or { dest: modrm.register().into(), src: modrm.effective().into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 282 - instructions8::Or { dest: modrm.register().into(), src: modrm.effective().into() }.into(), [INFO] [stdout] 282 + instructions8::Or { dest: modrm.register(), src: modrm.effective().into() }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 282 - instructions8::Or { dest: modrm.register().into(), src: modrm.effective().into() }.into(), [INFO] [stdout] 282 + instructions8::Or { dest: as Into<_>>::into(modrm.register()), src: modrm.effective().into() }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:284:44 [INFO] [stdout] | [INFO] [stdout] 284 | instructions16::Or { dest: modrm.register().into(), src: modrm.effective().into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 284 - instructions16::Or { dest: modrm.register().into(), src: modrm.effective().into() }.into(), [INFO] [stdout] 284 + instructions16::Or { dest: modrm.register(), src: modrm.effective().into() }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 284 - instructions16::Or { dest: modrm.register().into(), src: modrm.effective().into() }.into(), [INFO] [stdout] 284 + instructions16::Or { dest: as Into<_>>::into(modrm.register()), src: modrm.effective().into() }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:292:44 [INFO] [stdout] | [INFO] [stdout] 292 | instructions8::Adc { dest: modrm.effective().into(), src: modrm.register().into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 292 - instructions8::Adc { dest: modrm.effective().into(), src: modrm.register().into() }.into(), [INFO] [stdout] 292 + instructions8::Adc { dest: modrm.effective(), src: modrm.register().into() }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 292 - instructions8::Adc { dest: modrm.effective().into(), src: modrm.register().into() }.into(), [INFO] [stdout] 292 + instructions8::Adc { dest: as Into<_>>::into(modrm.effective()), src: modrm.register().into() }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:294:45 [INFO] [stdout] | [INFO] [stdout] 294 | instructions16::Adc { dest: modrm.effective().into(), src: modrm.register().into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 294 - instructions16::Adc { dest: modrm.effective().into(), src: modrm.register().into() }.into(), [INFO] [stdout] 294 + instructions16::Adc { dest: modrm.effective(), src: modrm.register().into() }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 294 - instructions16::Adc { dest: modrm.effective().into(), src: modrm.register().into() }.into(), [INFO] [stdout] 294 + instructions16::Adc { dest: as Into<_>>::into(modrm.effective()), src: modrm.register().into() }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:296:44 [INFO] [stdout] | [INFO] [stdout] 296 | instructions8::Adc { dest: modrm.register().into(), src: modrm.effective().into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 296 - instructions8::Adc { dest: modrm.register().into(), src: modrm.effective().into() }.into(), [INFO] [stdout] 296 + instructions8::Adc { dest: modrm.register(), src: modrm.effective().into() }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 296 - instructions8::Adc { dest: modrm.register().into(), src: modrm.effective().into() }.into(), [INFO] [stdout] 296 + instructions8::Adc { dest: as Into<_>>::into(modrm.register()), src: modrm.effective().into() }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:298:45 [INFO] [stdout] | [INFO] [stdout] 298 | instructions16::Adc { dest: modrm.register().into(), src: modrm.effective().into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 298 - instructions16::Adc { dest: modrm.register().into(), src: modrm.effective().into() }.into(), [INFO] [stdout] 298 + instructions16::Adc { dest: modrm.register(), src: modrm.effective().into() }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 298 - instructions16::Adc { dest: modrm.register().into(), src: modrm.effective().into() }.into(), [INFO] [stdout] 298 + instructions16::Adc { dest: as Into<_>>::into(modrm.register()), src: modrm.effective().into() }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:308:44 [INFO] [stdout] | [INFO] [stdout] 308 | instructions8::Sbb { dest: modrm.effective().into(), src: modrm.register().into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 308 - instructions8::Sbb { dest: modrm.effective().into(), src: modrm.register().into() }.into(), [INFO] [stdout] 308 + instructions8::Sbb { dest: modrm.effective(), src: modrm.register().into() }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 308 - instructions8::Sbb { dest: modrm.effective().into(), src: modrm.register().into() }.into(), [INFO] [stdout] 308 + instructions8::Sbb { dest: as Into<_>>::into(modrm.effective()), src: modrm.register().into() }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:310:45 [INFO] [stdout] | [INFO] [stdout] 310 | instructions16::Sbb { dest: modrm.effective().into(), src: modrm.register().into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 310 - instructions16::Sbb { dest: modrm.effective().into(), src: modrm.register().into() }.into(), [INFO] [stdout] 310 + instructions16::Sbb { dest: modrm.effective(), src: modrm.register().into() }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 310 - instructions16::Sbb { dest: modrm.effective().into(), src: modrm.register().into() }.into(), [INFO] [stdout] 310 + instructions16::Sbb { dest: as Into<_>>::into(modrm.effective()), src: modrm.register().into() }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:312:44 [INFO] [stdout] | [INFO] [stdout] 312 | instructions8::Sbb { dest: modrm.register().into(), src: modrm.effective().into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 312 - instructions8::Sbb { dest: modrm.register().into(), src: modrm.effective().into() }.into(), [INFO] [stdout] 312 + instructions8::Sbb { dest: modrm.register(), src: modrm.effective().into() }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 312 - instructions8::Sbb { dest: modrm.register().into(), src: modrm.effective().into() }.into(), [INFO] [stdout] 312 + instructions8::Sbb { dest: as Into<_>>::into(modrm.register()), src: modrm.effective().into() }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:314:45 [INFO] [stdout] | [INFO] [stdout] 314 | instructions16::Sbb { dest: modrm.register().into(), src: modrm.effective().into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 314 - instructions16::Sbb { dest: modrm.register().into(), src: modrm.effective().into() }.into(), [INFO] [stdout] 314 + instructions16::Sbb { dest: modrm.register(), src: modrm.effective().into() }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 314 - instructions16::Sbb { dest: modrm.register().into(), src: modrm.effective().into() }.into(), [INFO] [stdout] 314 + instructions16::Sbb { dest: as Into<_>>::into(modrm.register()), src: modrm.effective().into() }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:324:44 [INFO] [stdout] | [INFO] [stdout] 324 | instructions8::And { dest: modrm.effective().into(), src: modrm.register().into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 324 - instructions8::And { dest: modrm.effective().into(), src: modrm.register().into() }.into(), [INFO] [stdout] 324 + instructions8::And { dest: modrm.effective(), src: modrm.register().into() }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 324 - instructions8::And { dest: modrm.effective().into(), src: modrm.register().into() }.into(), [INFO] [stdout] 324 + instructions8::And { dest: as Into<_>>::into(modrm.effective()), src: modrm.register().into() }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:326:45 [INFO] [stdout] | [INFO] [stdout] 326 | instructions16::And { dest: modrm.effective().into(), src: modrm.register().into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 326 - instructions16::And { dest: modrm.effective().into(), src: modrm.register().into() }.into(), [INFO] [stdout] 326 + instructions16::And { dest: modrm.effective(), src: modrm.register().into() }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 326 - instructions16::And { dest: modrm.effective().into(), src: modrm.register().into() }.into(), [INFO] [stdout] 326 + instructions16::And { dest: as Into<_>>::into(modrm.effective()), src: modrm.register().into() }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:328:44 [INFO] [stdout] | [INFO] [stdout] 328 | instructions8::And { dest: modrm.register().into(), src: modrm.effective().into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 328 - instructions8::And { dest: modrm.register().into(), src: modrm.effective().into() }.into(), [INFO] [stdout] 328 + instructions8::And { dest: modrm.register(), src: modrm.effective().into() }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 328 - instructions8::And { dest: modrm.register().into(), src: modrm.effective().into() }.into(), [INFO] [stdout] 328 + instructions8::And { dest: as Into<_>>::into(modrm.register()), src: modrm.effective().into() }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:330:45 [INFO] [stdout] | [INFO] [stdout] 330 | instructions16::And { dest: modrm.register().into(), src: modrm.effective().into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 330 - instructions16::And { dest: modrm.register().into(), src: modrm.effective().into() }.into(), [INFO] [stdout] 330 + instructions16::And { dest: modrm.register(), src: modrm.effective().into() }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 330 - instructions16::And { dest: modrm.register().into(), src: modrm.effective().into() }.into(), [INFO] [stdout] 330 + instructions16::And { dest: as Into<_>>::into(modrm.register()), src: modrm.effective().into() }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:337:44 [INFO] [stdout] | [INFO] [stdout] 337 | instructions8::Sub { dest: modrm.effective().into(), src: modrm.register().into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 337 - instructions8::Sub { dest: modrm.effective().into(), src: modrm.register().into() }.into(), [INFO] [stdout] 337 + instructions8::Sub { dest: modrm.effective(), src: modrm.register().into() }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 337 - instructions8::Sub { dest: modrm.effective().into(), src: modrm.register().into() }.into(), [INFO] [stdout] 337 + instructions8::Sub { dest: as Into<_>>::into(modrm.effective()), src: modrm.register().into() }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:339:45 [INFO] [stdout] | [INFO] [stdout] 339 | instructions16::Sub { dest: modrm.effective().into(), src: modrm.register().into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 339 - instructions16::Sub { dest: modrm.effective().into(), src: modrm.register().into() }.into(), [INFO] [stdout] 339 + instructions16::Sub { dest: modrm.effective(), src: modrm.register().into() }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 339 - instructions16::Sub { dest: modrm.effective().into(), src: modrm.register().into() }.into(), [INFO] [stdout] 339 + instructions16::Sub { dest: as Into<_>>::into(modrm.effective()), src: modrm.register().into() }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:341:44 [INFO] [stdout] | [INFO] [stdout] 341 | instructions8::Sub { dest: modrm.register().into(), src: modrm.effective().into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 341 - instructions8::Sub { dest: modrm.register().into(), src: modrm.effective().into() }.into(), [INFO] [stdout] 341 + instructions8::Sub { dest: modrm.register(), src: modrm.effective().into() }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 341 - instructions8::Sub { dest: modrm.register().into(), src: modrm.effective().into() }.into(), [INFO] [stdout] 341 + instructions8::Sub { dest: as Into<_>>::into(modrm.register()), src: modrm.effective().into() }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:343:45 [INFO] [stdout] | [INFO] [stdout] 343 | instructions16::Sub { dest: modrm.register().into(), src: modrm.effective().into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 343 - instructions16::Sub { dest: modrm.register().into(), src: modrm.effective().into() }.into(), [INFO] [stdout] 343 + instructions16::Sub { dest: modrm.register(), src: modrm.effective().into() }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 343 - instructions16::Sub { dest: modrm.register().into(), src: modrm.effective().into() }.into(), [INFO] [stdout] 343 + instructions16::Sub { dest: as Into<_>>::into(modrm.register()), src: modrm.effective().into() }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:350:44 [INFO] [stdout] | [INFO] [stdout] 350 | instructions8::Xor { dest: modrm.effective().into(), src: modrm.register().into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 350 - instructions8::Xor { dest: modrm.effective().into(), src: modrm.register().into() }.into(), [INFO] [stdout] 350 + instructions8::Xor { dest: modrm.effective(), src: modrm.register().into() }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 350 - instructions8::Xor { dest: modrm.effective().into(), src: modrm.register().into() }.into(), [INFO] [stdout] 350 + instructions8::Xor { dest: as Into<_>>::into(modrm.effective()), src: modrm.register().into() }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:352:45 [INFO] [stdout] | [INFO] [stdout] 352 | instructions16::Xor { dest: modrm.effective().into(), src: modrm.register().into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 352 - instructions16::Xor { dest: modrm.effective().into(), src: modrm.register().into() }.into(), [INFO] [stdout] 352 + instructions16::Xor { dest: modrm.effective(), src: modrm.register().into() }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 352 - instructions16::Xor { dest: modrm.effective().into(), src: modrm.register().into() }.into(), [INFO] [stdout] 352 + instructions16::Xor { dest: as Into<_>>::into(modrm.effective()), src: modrm.register().into() }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:354:44 [INFO] [stdout] | [INFO] [stdout] 354 | instructions8::Xor { dest: modrm.register().into(), src: modrm.effective().into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 354 - instructions8::Xor { dest: modrm.register().into(), src: modrm.effective().into() }.into(), [INFO] [stdout] 354 + instructions8::Xor { dest: modrm.register(), src: modrm.effective().into() }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 354 - instructions8::Xor { dest: modrm.register().into(), src: modrm.effective().into() }.into(), [INFO] [stdout] 354 + instructions8::Xor { dest: as Into<_>>::into(modrm.register()), src: modrm.effective().into() }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:356:45 [INFO] [stdout] | [INFO] [stdout] 356 | instructions16::Xor { dest: modrm.register().into(), src: modrm.effective().into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 356 - instructions16::Xor { dest: modrm.register().into(), src: modrm.effective().into() }.into(), [INFO] [stdout] 356 + instructions16::Xor { dest: modrm.register(), src: modrm.effective().into() }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 356 - instructions16::Xor { dest: modrm.register().into(), src: modrm.effective().into() }.into(), [INFO] [stdout] 356 + instructions16::Xor { dest: as Into<_>>::into(modrm.register()), src: modrm.effective().into() }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:378:44 [INFO] [stdout] | [INFO] [stdout] 378 | instructions::Arpl { dest: modrm.effective().into(), src: modrm.register().into() } .into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 378 - instructions::Arpl { dest: modrm.effective().into(), src: modrm.register().into() } .into(), [INFO] [stdout] 378 + instructions::Arpl { dest: modrm.effective(), src: modrm.register().into() } .into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 378 - instructions::Arpl { dest: modrm.effective().into(), src: modrm.register().into() } .into(), [INFO] [stdout] 378 + instructions::Arpl { dest: as Into<_>>::into(modrm.effective()), src: modrm.register().into() } .into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:382:24 [INFO] [stdout] | [INFO] [stdout] 382 | dest1: modrm.register().into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 382 - dest1: modrm.register().into(), [INFO] [stdout] 382 + dest1: modrm.register(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 382 - dest1: modrm.register().into(), [INFO] [stdout] 382 + dest1: as Into<_>>::into(modrm.register()), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:388:24 [INFO] [stdout] | [INFO] [stdout] 388 | dest1: modrm.register().into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 388 - dest1: modrm.register().into(), [INFO] [stdout] 388 + dest1: modrm.register(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 388 - dest1: modrm.register().into(), [INFO] [stdout] 388 + dest1: as Into<_>>::into(modrm.register()), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `i8` [INFO] [stdout] --> src/disasm/decoder.rs:397:45 [INFO] [stdout] | [INFO] [stdout] 397 | instructions8::Jo { offset: offset.into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 397 - instructions8::Jo { offset: offset.into() }.into(), [INFO] [stdout] 397 + instructions8::Jo { offset: offset }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 397 - instructions8::Jo { offset: offset.into() }.into(), [INFO] [stdout] 397 + instructions8::Jo { offset: >::into(offset) }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `i8` [INFO] [stdout] --> src/disasm/decoder.rs:399:46 [INFO] [stdout] | [INFO] [stdout] 399 | instructions8::Jno { offset: offset.into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 399 - instructions8::Jno { offset: offset.into() }.into(), [INFO] [stdout] 399 + instructions8::Jno { offset: offset }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 399 - instructions8::Jno { offset: offset.into() }.into(), [INFO] [stdout] 399 + instructions8::Jno { offset: >::into(offset) }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `i8` [INFO] [stdout] --> src/disasm/decoder.rs:401:45 [INFO] [stdout] | [INFO] [stdout] 401 | instructions8::Jb { offset: offset.into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 401 - instructions8::Jb { offset: offset.into() }.into(), [INFO] [stdout] 401 + instructions8::Jb { offset: offset }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 401 - instructions8::Jb { offset: offset.into() }.into(), [INFO] [stdout] 401 + instructions8::Jb { offset: >::into(offset) }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `i8` [INFO] [stdout] --> src/disasm/decoder.rs:403:46 [INFO] [stdout] | [INFO] [stdout] 403 | instructions8::Jae { offset: offset.into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 403 - instructions8::Jae { offset: offset.into() }.into(), [INFO] [stdout] 403 + instructions8::Jae { offset: offset }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 403 - instructions8::Jae { offset: offset.into() }.into(), [INFO] [stdout] 403 + instructions8::Jae { offset: >::into(offset) }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `i8` [INFO] [stdout] --> src/disasm/decoder.rs:405:45 [INFO] [stdout] | [INFO] [stdout] 405 | instructions8::Je { offset: offset.into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 405 - instructions8::Je { offset: offset.into() }.into(), [INFO] [stdout] 405 + instructions8::Je { offset: offset }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 405 - instructions8::Je { offset: offset.into() }.into(), [INFO] [stdout] 405 + instructions8::Je { offset: >::into(offset) }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `i8` [INFO] [stdout] --> src/disasm/decoder.rs:407:46 [INFO] [stdout] | [INFO] [stdout] 407 | instructions8::Jne { offset: offset.into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 407 - instructions8::Jne { offset: offset.into() }.into(), [INFO] [stdout] 407 + instructions8::Jne { offset: offset }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 407 - instructions8::Jne { offset: offset.into() }.into(), [INFO] [stdout] 407 + instructions8::Jne { offset: >::into(offset) }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `i8` [INFO] [stdout] --> src/disasm/decoder.rs:409:46 [INFO] [stdout] | [INFO] [stdout] 409 | instructions8::Jbe { offset: offset.into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 409 - instructions8::Jbe { offset: offset.into() }.into(), [INFO] [stdout] 409 + instructions8::Jbe { offset: offset }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 409 - instructions8::Jbe { offset: offset.into() }.into(), [INFO] [stdout] 409 + instructions8::Jbe { offset: >::into(offset) }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `i8` [INFO] [stdout] --> src/disasm/decoder.rs:411:45 [INFO] [stdout] | [INFO] [stdout] 411 | instructions8::Ja { offset: offset.into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 411 - instructions8::Ja { offset: offset.into() }.into(), [INFO] [stdout] 411 + instructions8::Ja { offset: offset }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 411 - instructions8::Ja { offset: offset.into() }.into(), [INFO] [stdout] 411 + instructions8::Ja { offset: >::into(offset) }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `i8` [INFO] [stdout] --> src/disasm/decoder.rs:413:45 [INFO] [stdout] | [INFO] [stdout] 413 | instructions8::Js { offset: offset.into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 413 - instructions8::Js { offset: offset.into() }.into(), [INFO] [stdout] 413 + instructions8::Js { offset: offset }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 413 - instructions8::Js { offset: offset.into() }.into(), [INFO] [stdout] 413 + instructions8::Js { offset: >::into(offset) }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `i8` [INFO] [stdout] --> src/disasm/decoder.rs:415:46 [INFO] [stdout] | [INFO] [stdout] 415 | instructions8::Jns { offset: offset.into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 415 - instructions8::Jns { offset: offset.into() }.into(), [INFO] [stdout] 415 + instructions8::Jns { offset: offset }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 415 - instructions8::Jns { offset: offset.into() }.into(), [INFO] [stdout] 415 + instructions8::Jns { offset: >::into(offset) }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `i8` [INFO] [stdout] --> src/disasm/decoder.rs:417:45 [INFO] [stdout] | [INFO] [stdout] 417 | instructions8::Jp { offset: offset.into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 417 - instructions8::Jp { offset: offset.into() }.into(), [INFO] [stdout] 417 + instructions8::Jp { offset: offset }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 417 - instructions8::Jp { offset: offset.into() }.into(), [INFO] [stdout] 417 + instructions8::Jp { offset: >::into(offset) }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `i8` [INFO] [stdout] --> src/disasm/decoder.rs:419:46 [INFO] [stdout] | [INFO] [stdout] 419 | instructions8::Jnp { offset: offset.into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 419 - instructions8::Jnp { offset: offset.into() }.into(), [INFO] [stdout] 419 + instructions8::Jnp { offset: offset }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 419 - instructions8::Jnp { offset: offset.into() }.into(), [INFO] [stdout] 419 + instructions8::Jnp { offset: >::into(offset) }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `i8` [INFO] [stdout] --> src/disasm/decoder.rs:421:45 [INFO] [stdout] | [INFO] [stdout] 421 | instructions8::Jl { offset: offset.into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 421 - instructions8::Jl { offset: offset.into() }.into(), [INFO] [stdout] 421 + instructions8::Jl { offset: offset }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 421 - instructions8::Jl { offset: offset.into() }.into(), [INFO] [stdout] 421 + instructions8::Jl { offset: >::into(offset) }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `i8` [INFO] [stdout] --> src/disasm/decoder.rs:423:46 [INFO] [stdout] | [INFO] [stdout] 423 | instructions8::Jge { offset: offset.into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 423 - instructions8::Jge { offset: offset.into() }.into(), [INFO] [stdout] 423 + instructions8::Jge { offset: offset }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 423 - instructions8::Jge { offset: offset.into() }.into(), [INFO] [stdout] 423 + instructions8::Jge { offset: >::into(offset) }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `i8` [INFO] [stdout] --> src/disasm/decoder.rs:425:46 [INFO] [stdout] | [INFO] [stdout] 425 | instructions8::Jle { offset: offset.into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 425 - instructions8::Jle { offset: offset.into() }.into(), [INFO] [stdout] 425 + instructions8::Jle { offset: offset }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 425 - instructions8::Jle { offset: offset.into() }.into(), [INFO] [stdout] 425 + instructions8::Jle { offset: >::into(offset) }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `i8` [INFO] [stdout] --> src/disasm/decoder.rs:427:45 [INFO] [stdout] | [INFO] [stdout] 427 | instructions8::Jg { offset: offset.into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 427 - instructions8::Jg { offset: offset.into() }.into(), [INFO] [stdout] 427 + instructions8::Jg { offset: offset }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 427 - instructions8::Jg { offset: offset.into() }.into(), [INFO] [stdout] 427 + instructions8::Jg { offset: >::into(offset) }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:433:42 [INFO] [stdout] | [INFO] [stdout] 433 | instructions8::Xchg { a: modrm.effective().into(), b: modrm.register().into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 433 - instructions8::Xchg { a: modrm.effective().into(), b: modrm.register().into() }.into(), [INFO] [stdout] 433 + instructions8::Xchg { a: modrm.effective(), b: modrm.register().into() }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 433 - instructions8::Xchg { a: modrm.effective().into(), b: modrm.register().into() }.into(), [INFO] [stdout] 433 + instructions8::Xchg { a: as Into<_>>::into(modrm.effective()), b: modrm.register().into() }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:433:71 [INFO] [stdout] | [INFO] [stdout] 433 | instructions8::Xchg { a: modrm.effective().into(), b: modrm.register().into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 433 - instructions8::Xchg { a: modrm.effective().into(), b: modrm.register().into() }.into(), [INFO] [stdout] 433 + instructions8::Xchg { a: modrm.effective().into(), b: modrm.register() }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 433 - instructions8::Xchg { a: modrm.effective().into(), b: modrm.register().into() }.into(), [INFO] [stdout] 433 + instructions8::Xchg { a: modrm.effective().into(), b: as Into<_>>::into(modrm.register()) }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:435:43 [INFO] [stdout] | [INFO] [stdout] 435 | instructions16::Xchg { a: modrm.effective().into(), b: modrm.register().into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 435 - instructions16::Xchg { a: modrm.effective().into(), b: modrm.register().into() }.into(), [INFO] [stdout] 435 + instructions16::Xchg { a: modrm.effective(), b: modrm.register().into() }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 435 - instructions16::Xchg { a: modrm.effective().into(), b: modrm.register().into() }.into(), [INFO] [stdout] 435 + instructions16::Xchg { a: as Into<_>>::into(modrm.effective()), b: modrm.register().into() }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:435:72 [INFO] [stdout] | [INFO] [stdout] 435 | instructions16::Xchg { a: modrm.effective().into(), b: modrm.register().into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 435 - instructions16::Xchg { a: modrm.effective().into(), b: modrm.register().into() }.into(), [INFO] [stdout] 435 + instructions16::Xchg { a: modrm.effective().into(), b: modrm.register() }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 435 - instructions16::Xchg { a: modrm.effective().into(), b: modrm.register().into() }.into(), [INFO] [stdout] 435 + instructions16::Xchg { a: modrm.effective().into(), b: as Into<_>>::into(modrm.register()) }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:437:44 [INFO] [stdout] | [INFO] [stdout] 437 | instructions8::Mov { dest: modrm.effective().into(), src: modrm.register().into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 437 - instructions8::Mov { dest: modrm.effective().into(), src: modrm.register().into() }.into(), [INFO] [stdout] 437 + instructions8::Mov { dest: modrm.effective(), src: modrm.register().into() }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 437 - instructions8::Mov { dest: modrm.effective().into(), src: modrm.register().into() }.into(), [INFO] [stdout] 437 + instructions8::Mov { dest: as Into<_>>::into(modrm.effective()), src: modrm.register().into() }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:439:45 [INFO] [stdout] | [INFO] [stdout] 439 | instructions16::Mov { dest: modrm.effective().into(), src: modrm.register().into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 439 - instructions16::Mov { dest: modrm.effective().into(), src: modrm.register().into() }.into(), [INFO] [stdout] 439 + instructions16::Mov { dest: modrm.effective(), src: modrm.register().into() }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 439 - instructions16::Mov { dest: modrm.effective().into(), src: modrm.register().into() }.into(), [INFO] [stdout] 439 + instructions16::Mov { dest: as Into<_>>::into(modrm.effective()), src: modrm.register().into() }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:441:44 [INFO] [stdout] | [INFO] [stdout] 441 | instructions8::Mov { dest: modrm.register().into(), src: modrm.effective().into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 441 - instructions8::Mov { dest: modrm.register().into(), src: modrm.effective().into() }.into(), [INFO] [stdout] 441 + instructions8::Mov { dest: modrm.register(), src: modrm.effective().into() }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 441 - instructions8::Mov { dest: modrm.register().into(), src: modrm.effective().into() }.into(), [INFO] [stdout] 441 + instructions8::Mov { dest: as Into<_>>::into(modrm.register()), src: modrm.effective().into() }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:443:45 [INFO] [stdout] | [INFO] [stdout] 443 | instructions16::Mov { dest: modrm.register().into(), src: modrm.effective().into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 443 - instructions16::Mov { dest: modrm.register().into(), src: modrm.effective().into() }.into(), [INFO] [stdout] 443 + instructions16::Mov { dest: modrm.register(), src: modrm.effective().into() }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 443 - instructions16::Mov { dest: modrm.register().into(), src: modrm.effective().into() }.into(), [INFO] [stdout] 443 + instructions16::Mov { dest: as Into<_>>::into(modrm.register()), src: modrm.effective().into() }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:445:45 [INFO] [stdout] | [INFO] [stdout] 445 | instructions16::Mov { dest: modrm.effective().into(), src: modrm.segment_register()?.into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 445 - instructions16::Mov { dest: modrm.effective().into(), src: modrm.segment_register()?.into() }.into(), [INFO] [stdout] 445 + instructions16::Mov { dest: modrm.effective(), src: modrm.segment_register()?.into() }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 445 - instructions16::Mov { dest: modrm.effective().into(), src: modrm.segment_register()?.into() }.into(), [INFO] [stdout] 445 + instructions16::Mov { dest: as Into<_>>::into(modrm.effective()), src: modrm.segment_register()?.into() }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:446:64 [INFO] [stdout] | [INFO] [stdout] 446 | [0x8D, modrm @ ModRM] => instructions::Lea { dest: modrm.register().into(), src: modrm.memory()? }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 446 - [0x8D, modrm @ ModRM] => instructions::Lea { dest: modrm.register().into(), src: modrm.memory()? }.into(), [INFO] [stdout] 446 + [0x8D, modrm @ ModRM] => instructions::Lea { dest: modrm.register(), src: modrm.memory()? }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 446 - [0x8D, modrm @ ModRM] => instructions::Lea { dest: modrm.register().into(), src: modrm.memory()? }.into(), [INFO] [stdout] 446 + [0x8D, modrm @ ModRM] => instructions::Lea { dest: as Into<_>>::into(modrm.register()), src: modrm.memory()? }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:448:45 [INFO] [stdout] | [INFO] [stdout] 448 | instructions16::Mov { dest: modrm.segment_register()?.into(), src: modrm.effective().into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 448 - instructions16::Mov { dest: modrm.segment_register()?.into(), src: modrm.effective().into() }.into(), [INFO] [stdout] 448 + instructions16::Mov { dest: modrm.segment_register()?, src: modrm.effective().into() }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 448 - instructions16::Mov { dest: modrm.segment_register()?.into(), src: modrm.effective().into() }.into(), [INFO] [stdout] 448 + instructions16::Mov { dest: as Into<_>>::into(modrm.segment_register()?), src: modrm.effective().into() }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:450:45 [INFO] [stdout] | [INFO] [stdout] 450 | instructions16::Pop { dest: modrm.effective().into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 450 - instructions16::Pop { dest: modrm.effective().into() }.into(), [INFO] [stdout] 450 + instructions16::Pop { dest: modrm.effective() }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 450 - instructions16::Pop { dest: modrm.effective().into() }.into(), [INFO] [stdout] 450 + instructions16::Pop { dest: as Into<_>>::into(modrm.effective()) }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u16` [INFO] [stdout] --> src/disasm/decoder.rs:484:48 [INFO] [stdout] | [INFO] [stdout] 484 | instructions::RetNear { count: count.into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 484 - instructions::RetNear { count: count.into() }.into(), [INFO] [stdout] 484 + instructions::RetNear { count: count }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 484 - instructions::RetNear { count: count.into() }.into(), [INFO] [stdout] 484 + instructions::RetNear { count: >::into(count) }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:487:43 [INFO] [stdout] | [INFO] [stdout] 487 | instructions::Les { dest: modrm.register().into(), src: modrm.memory()?.into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 487 - instructions::Les { dest: modrm.register().into(), src: modrm.memory()?.into() }.into(), [INFO] [stdout] 487 + instructions::Les { dest: modrm.register(), src: modrm.memory()?.into() }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 487 - instructions::Les { dest: modrm.register().into(), src: modrm.memory()?.into() }.into(), [INFO] [stdout] 487 + instructions::Les { dest: as Into<_>>::into(modrm.register()), src: modrm.memory()?.into() }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:489:43 [INFO] [stdout] | [INFO] [stdout] 489 | instructions::Lds { dest: modrm.register().into(), src: modrm.memory()?.into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 489 - instructions::Lds { dest: modrm.register().into(), src: modrm.memory()?.into() }.into(), [INFO] [stdout] 489 + instructions::Lds { dest: modrm.register(), src: modrm.memory()?.into() }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 489 - instructions::Lds { dest: modrm.register().into(), src: modrm.memory()?.into() }.into(), [INFO] [stdout] 489 + instructions::Lds { dest: as Into<_>>::into(modrm.register()), src: modrm.memory()?.into() }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:491:44 [INFO] [stdout] | [INFO] [stdout] 491 | instructions8::Mov { dest: modrm.effective().into(), src: src.into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 491 - instructions8::Mov { dest: modrm.effective().into(), src: src.into() }.into(), [INFO] [stdout] 491 + instructions8::Mov { dest: modrm.effective(), src: src.into() }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 491 - instructions8::Mov { dest: modrm.effective().into(), src: src.into() }.into(), [INFO] [stdout] 491 + instructions8::Mov { dest: as Into<_>>::into(modrm.effective()), src: src.into() }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:493:45 [INFO] [stdout] | [INFO] [stdout] 493 | instructions16::Mov { dest: modrm.effective().into(), src: src.into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 493 - instructions16::Mov { dest: modrm.effective().into(), src: src.into() }.into(), [INFO] [stdout] 493 + instructions16::Mov { dest: modrm.effective(), src: src.into() }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 493 - instructions16::Mov { dest: modrm.effective().into(), src: src.into() }.into(), [INFO] [stdout] 493 + instructions16::Mov { dest: as Into<_>>::into(modrm.effective()), src: src.into() }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u16` [INFO] [stdout] --> src/disasm/decoder.rs:495:47 [INFO] [stdout] | [INFO] [stdout] 495 | instructions::RetFar { count: count.into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 495 - instructions::RetFar { count: count.into() }.into(), [INFO] [stdout] 495 + instructions::RetFar { count: count }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 495 - instructions::RetFar { count: count.into() }.into(), [INFO] [stdout] 495 + instructions::RetFar { count: >::into(count) }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `i8` [INFO] [stdout] --> src/disasm/decoder.rs:509:47 [INFO] [stdout] | [INFO] [stdout] 509 | instructions::Loope { offset: offset.into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 509 - instructions::Loope { offset: offset.into() }.into(), [INFO] [stdout] 509 + instructions::Loope { offset: offset }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 509 - instructions::Loope { offset: offset.into() }.into(), [INFO] [stdout] 509 + instructions::Loope { offset: >::into(offset) }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `i8` [INFO] [stdout] --> src/disasm/decoder.rs:511:46 [INFO] [stdout] | [INFO] [stdout] 511 | instructions::Loop { offset: offset.into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 511 - instructions::Loop { offset: offset.into() }.into(), [INFO] [stdout] 511 + instructions::Loop { offset: offset }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 511 - instructions::Loop { offset: offset.into() }.into(), [INFO] [stdout] 511 + instructions::Loop { offset: >::into(offset) }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `i8` [INFO] [stdout] --> src/disasm/decoder.rs:513:46 [INFO] [stdout] | [INFO] [stdout] 513 | instructions::Jcxz { offset: offset.into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 513 - instructions::Jcxz { offset: offset.into() }.into(), [INFO] [stdout] 513 + instructions::Jcxz { offset: offset }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 513 - instructions::Jcxz { offset: offset.into() }.into(), [INFO] [stdout] 513 + instructions::Jcxz { offset: >::into(offset) }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `i16` [INFO] [stdout] --> src/disasm/decoder.rs:523:49 [INFO] [stdout] | [INFO] [stdout] 523 | instructions::CallRel { offset: offset.into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 523 - instructions::CallRel { offset: offset.into() }.into(), [INFO] [stdout] 523 + instructions::CallRel { offset: offset }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 523 - instructions::CallRel { offset: offset.into() }.into(), [INFO] [stdout] 523 + instructions::CallRel { offset: >::into(offset) }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `i16` [INFO] [stdout] --> src/disasm/decoder.rs:525:50 [INFO] [stdout] | [INFO] [stdout] 525 | instructions16::JmpRel { offset: offset.into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 525 - instructions16::JmpRel { offset: offset.into() }.into(), [INFO] [stdout] 525 + instructions16::JmpRel { offset: offset }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 525 - instructions16::JmpRel { offset: offset.into() }.into(), [INFO] [stdout] 525 + instructions16::JmpRel { offset: >::into(offset) }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `i8` [INFO] [stdout] --> src/disasm/decoder.rs:529:49 [INFO] [stdout] | [INFO] [stdout] 529 | instructions8::JmpRel { offset: offset.into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 529 - instructions8::JmpRel { offset: offset.into() }.into(), [INFO] [stdout] 529 + instructions8::JmpRel { offset: offset }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 529 - instructions8::JmpRel { offset: offset.into() }.into(), [INFO] [stdout] 529 + instructions8::JmpRel { offset: >::into(offset) }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `i16` [INFO] [stdout] --> src/disasm/decoder.rs:554:66 [INFO] [stdout] | [INFO] [stdout] 554 | [0x80, offset @ i16] => instructions16::Jo { offset: offset.into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 554 - [0x80, offset @ i16] => instructions16::Jo { offset: offset.into() }.into(), [INFO] [stdout] 554 + [0x80, offset @ i16] => instructions16::Jo { offset: offset }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 554 - [0x80, offset @ i16] => instructions16::Jo { offset: offset.into() }.into(), [INFO] [stdout] 554 + [0x80, offset @ i16] => instructions16::Jo { offset: >::into(offset) }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `i16` [INFO] [stdout] --> src/disasm/decoder.rs:555:67 [INFO] [stdout] | [INFO] [stdout] 555 | [0x81, offset @ i16] => instructions16::Jno { offset: offset.into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 555 - [0x81, offset @ i16] => instructions16::Jno { offset: offset.into() }.into(), [INFO] [stdout] 555 + [0x81, offset @ i16] => instructions16::Jno { offset: offset }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 555 - [0x81, offset @ i16] => instructions16::Jno { offset: offset.into() }.into(), [INFO] [stdout] 555 + [0x81, offset @ i16] => instructions16::Jno { offset: >::into(offset) }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `i16` [INFO] [stdout] --> src/disasm/decoder.rs:556:66 [INFO] [stdout] | [INFO] [stdout] 556 | [0x82, offset @ i16] => instructions16::Jb { offset: offset.into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 556 - [0x82, offset @ i16] => instructions16::Jb { offset: offset.into() }.into(), [INFO] [stdout] 556 + [0x82, offset @ i16] => instructions16::Jb { offset: offset }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 556 - [0x82, offset @ i16] => instructions16::Jb { offset: offset.into() }.into(), [INFO] [stdout] 556 + [0x82, offset @ i16] => instructions16::Jb { offset: >::into(offset) }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `i16` [INFO] [stdout] --> src/disasm/decoder.rs:557:67 [INFO] [stdout] | [INFO] [stdout] 557 | [0x83, offset @ i16] => instructions16::Jae { offset: offset.into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 557 - [0x83, offset @ i16] => instructions16::Jae { offset: offset.into() }.into(), [INFO] [stdout] 557 + [0x83, offset @ i16] => instructions16::Jae { offset: offset }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 557 - [0x83, offset @ i16] => instructions16::Jae { offset: offset.into() }.into(), [INFO] [stdout] 557 + [0x83, offset @ i16] => instructions16::Jae { offset: >::into(offset) }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `i16` [INFO] [stdout] --> src/disasm/decoder.rs:558:66 [INFO] [stdout] | [INFO] [stdout] 558 | [0x84, offset @ i16] => instructions16::Je { offset: offset.into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 558 - [0x84, offset @ i16] => instructions16::Je { offset: offset.into() }.into(), [INFO] [stdout] 558 + [0x84, offset @ i16] => instructions16::Je { offset: offset }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 558 - [0x84, offset @ i16] => instructions16::Je { offset: offset.into() }.into(), [INFO] [stdout] 558 + [0x84, offset @ i16] => instructions16::Je { offset: >::into(offset) }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `i16` [INFO] [stdout] --> src/disasm/decoder.rs:559:67 [INFO] [stdout] | [INFO] [stdout] 559 | [0x85, offset @ i16] => instructions16::Jne { offset: offset.into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 559 - [0x85, offset @ i16] => instructions16::Jne { offset: offset.into() }.into(), [INFO] [stdout] 559 + [0x85, offset @ i16] => instructions16::Jne { offset: offset }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 559 - [0x85, offset @ i16] => instructions16::Jne { offset: offset.into() }.into(), [INFO] [stdout] 559 + [0x85, offset @ i16] => instructions16::Jne { offset: >::into(offset) }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `i16` [INFO] [stdout] --> src/disasm/decoder.rs:560:67 [INFO] [stdout] | [INFO] [stdout] 560 | [0x86, offset @ i16] => instructions16::Jbe { offset: offset.into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 560 - [0x86, offset @ i16] => instructions16::Jbe { offset: offset.into() }.into(), [INFO] [stdout] 560 + [0x86, offset @ i16] => instructions16::Jbe { offset: offset }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 560 - [0x86, offset @ i16] => instructions16::Jbe { offset: offset.into() }.into(), [INFO] [stdout] 560 + [0x86, offset @ i16] => instructions16::Jbe { offset: >::into(offset) }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `i16` [INFO] [stdout] --> src/disasm/decoder.rs:561:66 [INFO] [stdout] | [INFO] [stdout] 561 | [0x87, offset @ i16] => instructions16::Ja { offset: offset.into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 561 - [0x87, offset @ i16] => instructions16::Ja { offset: offset.into() }.into(), [INFO] [stdout] 561 + [0x87, offset @ i16] => instructions16::Ja { offset: offset }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 561 - [0x87, offset @ i16] => instructions16::Ja { offset: offset.into() }.into(), [INFO] [stdout] 561 + [0x87, offset @ i16] => instructions16::Ja { offset: >::into(offset) }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `i16` [INFO] [stdout] --> src/disasm/decoder.rs:562:66 [INFO] [stdout] | [INFO] [stdout] 562 | [0x88, offset @ i16] => instructions16::Js { offset: offset.into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 562 - [0x88, offset @ i16] => instructions16::Js { offset: offset.into() }.into(), [INFO] [stdout] 562 + [0x88, offset @ i16] => instructions16::Js { offset: offset }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 562 - [0x88, offset @ i16] => instructions16::Js { offset: offset.into() }.into(), [INFO] [stdout] 562 + [0x88, offset @ i16] => instructions16::Js { offset: >::into(offset) }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `i16` [INFO] [stdout] --> src/disasm/decoder.rs:563:67 [INFO] [stdout] | [INFO] [stdout] 563 | [0x89, offset @ i16] => instructions16::Jns { offset: offset.into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 563 - [0x89, offset @ i16] => instructions16::Jns { offset: offset.into() }.into(), [INFO] [stdout] 563 + [0x89, offset @ i16] => instructions16::Jns { offset: offset }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 563 - [0x89, offset @ i16] => instructions16::Jns { offset: offset.into() }.into(), [INFO] [stdout] 563 + [0x89, offset @ i16] => instructions16::Jns { offset: >::into(offset) }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `i16` [INFO] [stdout] --> src/disasm/decoder.rs:564:66 [INFO] [stdout] | [INFO] [stdout] 564 | [0x8A, offset @ i16] => instructions16::Jp { offset: offset.into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 564 - [0x8A, offset @ i16] => instructions16::Jp { offset: offset.into() }.into(), [INFO] [stdout] 564 + [0x8A, offset @ i16] => instructions16::Jp { offset: offset }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 564 - [0x8A, offset @ i16] => instructions16::Jp { offset: offset.into() }.into(), [INFO] [stdout] 564 + [0x8A, offset @ i16] => instructions16::Jp { offset: >::into(offset) }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `i16` [INFO] [stdout] --> src/disasm/decoder.rs:565:67 [INFO] [stdout] | [INFO] [stdout] 565 | [0x8B, offset @ i16] => instructions16::Jnp { offset: offset.into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 565 - [0x8B, offset @ i16] => instructions16::Jnp { offset: offset.into() }.into(), [INFO] [stdout] 565 + [0x8B, offset @ i16] => instructions16::Jnp { offset: offset }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 565 - [0x8B, offset @ i16] => instructions16::Jnp { offset: offset.into() }.into(), [INFO] [stdout] 565 + [0x8B, offset @ i16] => instructions16::Jnp { offset: >::into(offset) }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `i16` [INFO] [stdout] --> src/disasm/decoder.rs:566:66 [INFO] [stdout] | [INFO] [stdout] 566 | [0x8C, offset @ i16] => instructions16::Jl { offset: offset.into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 566 - [0x8C, offset @ i16] => instructions16::Jl { offset: offset.into() }.into(), [INFO] [stdout] 566 + [0x8C, offset @ i16] => instructions16::Jl { offset: offset }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 566 - [0x8C, offset @ i16] => instructions16::Jl { offset: offset.into() }.into(), [INFO] [stdout] 566 + [0x8C, offset @ i16] => instructions16::Jl { offset: >::into(offset) }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `i16` [INFO] [stdout] --> src/disasm/decoder.rs:567:67 [INFO] [stdout] | [INFO] [stdout] 567 | [0x8D, offset @ i16] => instructions16::Jge { offset: offset.into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 567 - [0x8D, offset @ i16] => instructions16::Jge { offset: offset.into() }.into(), [INFO] [stdout] 567 + [0x8D, offset @ i16] => instructions16::Jge { offset: offset }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 567 - [0x8D, offset @ i16] => instructions16::Jge { offset: offset.into() }.into(), [INFO] [stdout] 567 + [0x8D, offset @ i16] => instructions16::Jge { offset: >::into(offset) }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `i16` [INFO] [stdout] --> src/disasm/decoder.rs:568:67 [INFO] [stdout] | [INFO] [stdout] 568 | [0x8E, offset @ i16] => instructions16::Jle { offset: offset.into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 568 - [0x8E, offset @ i16] => instructions16::Jle { offset: offset.into() }.into(), [INFO] [stdout] 568 + [0x8E, offset @ i16] => instructions16::Jle { offset: offset }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 568 - [0x8E, offset @ i16] => instructions16::Jle { offset: offset.into() }.into(), [INFO] [stdout] 568 + [0x8E, offset @ i16] => instructions16::Jle { offset: >::into(offset) }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `i16` [INFO] [stdout] --> src/disasm/decoder.rs:569:66 [INFO] [stdout] | [INFO] [stdout] 569 | [0x8F, offset @ i16] => instructions16::Jg { offset: offset.into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 569 - [0x8F, offset @ i16] => instructions16::Jg { offset: offset.into() }.into(), [INFO] [stdout] 569 + [0x8F, offset @ i16] => instructions16::Jg { offset: offset }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 569 - [0x8F, offset @ i16] => instructions16::Jg { offset: offset.into() }.into(), [INFO] [stdout] 569 + [0x8F, offset @ i16] => instructions16::Jg { offset: >::into(offset) }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:576:24 [INFO] [stdout] | [INFO] [stdout] 576 | dest1: modrm.register().into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 576 - dest1: modrm.register().into(), [INFO] [stdout] 576 + dest1: modrm.register(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 576 - dest1: modrm.register().into(), [INFO] [stdout] 576 + dest1: as Into<_>>::into(modrm.register()), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:582:43 [INFO] [stdout] | [INFO] [stdout] 582 | instructions::Lss { dest: modrm.register().into(), src: modrm.memory()?.into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 582 - instructions::Lss { dest: modrm.register().into(), src: modrm.memory()?.into() }.into(), [INFO] [stdout] 582 + instructions::Lss { dest: modrm.register(), src: modrm.memory()?.into() }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 582 - instructions::Lss { dest: modrm.register().into(), src: modrm.memory()?.into() }.into(), [INFO] [stdout] 582 + instructions::Lss { dest: as Into<_>>::into(modrm.register()), src: modrm.memory()?.into() }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:584:43 [INFO] [stdout] | [INFO] [stdout] 584 | instructions::Lfs { dest: modrm.register().into(), src: modrm.memory()?.into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 584 - instructions::Lfs { dest: modrm.register().into(), src: modrm.memory()?.into() }.into(), [INFO] [stdout] 584 + instructions::Lfs { dest: modrm.register(), src: modrm.memory()?.into() }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 584 - instructions::Lfs { dest: modrm.register().into(), src: modrm.memory()?.into() }.into(), [INFO] [stdout] 584 + instructions::Lfs { dest: as Into<_>>::into(modrm.register()), src: modrm.memory()?.into() }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:586:43 [INFO] [stdout] | [INFO] [stdout] 586 | instructions::Lgs { dest: modrm.register().into(), src: modrm.memory()?.into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 586 - instructions::Lgs { dest: modrm.register().into(), src: modrm.memory()?.into() }.into(), [INFO] [stdout] 586 + instructions::Lgs { dest: modrm.register(), src: modrm.memory()?.into() }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 586 - instructions::Lgs { dest: modrm.register().into(), src: modrm.memory()?.into() }.into(), [INFO] [stdout] 586 + instructions::Lgs { dest: as Into<_>>::into(modrm.register()), src: modrm.memory()?.into() }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:757:55 [INFO] [stdout] | [INFO] [stdout] 757 | return Ok(instructions16::Inc { dest: reg.into() }.into()); [INFO] [stdout] | ^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 757 - return Ok(instructions16::Inc { dest: reg.into() }.into()); [INFO] [stdout] 757 + return Ok(instructions16::Inc { dest: reg }.into()); [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 757 - return Ok(instructions16::Inc { dest: reg.into() }.into()); [INFO] [stdout] 757 + return Ok(instructions16::Inc { dest: as Into<_>>::into(reg) }.into()); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:761:55 [INFO] [stdout] | [INFO] [stdout] 761 | return Ok(instructions16::Dec { dest: reg.into() }.into()); [INFO] [stdout] | ^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 761 - return Ok(instructions16::Dec { dest: reg.into() }.into()); [INFO] [stdout] 761 + return Ok(instructions16::Dec { dest: reg }.into()); [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 761 - return Ok(instructions16::Dec { dest: reg.into() }.into()); [INFO] [stdout] 761 + return Ok(instructions16::Dec { dest: as Into<_>>::into(reg) }.into()); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:769:55 [INFO] [stdout] | [INFO] [stdout] 769 | return Ok(instructions16::Pop { dest: reg.into() }.into()); [INFO] [stdout] | ^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 769 - return Ok(instructions16::Pop { dest: reg.into() }.into()); [INFO] [stdout] 769 + return Ok(instructions16::Pop { dest: reg }.into()); [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 769 - return Ok(instructions16::Pop { dest: reg.into() }.into()); [INFO] [stdout] 769 + return Ok(instructions16::Pop { dest: as Into<_>>::into(reg) }.into()); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:778:79 [INFO] [stdout] | [INFO] [stdout] 778 | return Ok(instructions16::Xchg { a: Register16::AX.into(), b: reg.into() }.into()); [INFO] [stdout] | ^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 778 - return Ok(instructions16::Xchg { a: Register16::AX.into(), b: reg.into() }.into()); [INFO] [stdout] 778 + return Ok(instructions16::Xchg { a: Register16::AX.into(), b: reg }.into()); [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 778 - return Ok(instructions16::Xchg { a: Register16::AX.into(), b: reg.into() }.into()); [INFO] [stdout] 778 + return Ok(instructions16::Xchg { a: Register16::AX.into(), b: as Into<_>>::into(reg) }.into()); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:785:54 [INFO] [stdout] | [INFO] [stdout] 785 | return Ok(instructions8::Mov { dest: reg.into(), src: imm.into() }.into()); [INFO] [stdout] | ^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 785 - return Ok(instructions8::Mov { dest: reg.into(), src: imm.into() }.into()); [INFO] [stdout] 785 + return Ok(instructions8::Mov { dest: reg, src: imm.into() }.into()); [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 785 - return Ok(instructions8::Mov { dest: reg.into(), src: imm.into() }.into()); [INFO] [stdout] 785 + return Ok(instructions8::Mov { dest: as Into<_>>::into(reg), src: imm.into() }.into()); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:790:55 [INFO] [stdout] | [INFO] [stdout] 790 | return Ok(instructions16::Mov { dest: reg.into(), src: imm.into() }.into()); [INFO] [stdout] | ^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 790 - return Ok(instructions16::Mov { dest: reg.into(), src: imm.into() }.into()); [INFO] [stdout] 790 + return Ok(instructions16::Mov { dest: reg, src: imm.into() }.into()); [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 790 - return Ok(instructions16::Mov { dest: reg.into(), src: imm.into() }.into()); [INFO] [stdout] 790 + return Ok(instructions16::Mov { dest: as Into<_>>::into(reg), src: imm.into() }.into()); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: struct `IndependentSize` is never constructed [INFO] [stdout] --> src/disasm/instruction.rs:214:12 [INFO] [stdout] | [INFO] [stdout] 214 | pub struct IndependentSize; [INFO] [stdout] | ^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: `#[warn(dead_code)]` (part of `#[warn(unused)]`) on by default [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:262:44 [INFO] [stdout] | [INFO] [stdout] 262 | instructions8::Add { dest: modrm.effective().into(), src: modrm.register().into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: `#[deny(self_type_conversion)]` on by default [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 262 - instructions8::Add { dest: modrm.effective().into(), src: modrm.register().into() }.into(), [INFO] [stdout] 262 + instructions8::Add { dest: modrm.effective(), src: modrm.register().into() }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 262 - instructions8::Add { dest: modrm.effective().into(), src: modrm.register().into() }.into(), [INFO] [stdout] 262 + instructions8::Add { dest: as Into<_>>::into(modrm.effective()), src: modrm.register().into() }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:264:45 [INFO] [stdout] | [INFO] [stdout] 264 | instructions16::Add { dest: modrm.effective().into(), src: modrm.register().into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 264 - instructions16::Add { dest: modrm.effective().into(), src: modrm.register().into() }.into(), [INFO] [stdout] 264 + instructions16::Add { dest: modrm.effective(), src: modrm.register().into() }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 264 - instructions16::Add { dest: modrm.effective().into(), src: modrm.register().into() }.into(), [INFO] [stdout] 264 + instructions16::Add { dest: as Into<_>>::into(modrm.effective()), src: modrm.register().into() }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:266:44 [INFO] [stdout] | [INFO] [stdout] 266 | instructions8::Add { dest: modrm.register().into(), src: modrm.effective().into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 266 - instructions8::Add { dest: modrm.register().into(), src: modrm.effective().into() }.into(), [INFO] [stdout] 266 + instructions8::Add { dest: modrm.register(), src: modrm.effective().into() }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 266 - instructions8::Add { dest: modrm.register().into(), src: modrm.effective().into() }.into(), [INFO] [stdout] 266 + instructions8::Add { dest: as Into<_>>::into(modrm.register()), src: modrm.effective().into() }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:268:45 [INFO] [stdout] | [INFO] [stdout] 268 | instructions16::Add { dest: modrm.register().into(), src: modrm.effective().into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 268 - instructions16::Add { dest: modrm.register().into(), src: modrm.effective().into() }.into(), [INFO] [stdout] 268 + instructions16::Add { dest: modrm.register(), src: modrm.effective().into() }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 268 - instructions16::Add { dest: modrm.register().into(), src: modrm.effective().into() }.into(), [INFO] [stdout] 268 + instructions16::Add { dest: as Into<_>>::into(modrm.register()), src: modrm.effective().into() }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:278:43 [INFO] [stdout] | [INFO] [stdout] 278 | instructions8::Or { dest: modrm.effective().into(), src: modrm.register().into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 278 - instructions8::Or { dest: modrm.effective().into(), src: modrm.register().into() }.into(), [INFO] [stdout] 278 + instructions8::Or { dest: modrm.effective(), src: modrm.register().into() }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 278 - instructions8::Or { dest: modrm.effective().into(), src: modrm.register().into() }.into(), [INFO] [stdout] 278 + instructions8::Or { dest: as Into<_>>::into(modrm.effective()), src: modrm.register().into() }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:280:44 [INFO] [stdout] | [INFO] [stdout] 280 | instructions16::Or { dest: modrm.effective().into(), src: modrm.register().into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 280 - instructions16::Or { dest: modrm.effective().into(), src: modrm.register().into() }.into(), [INFO] [stdout] 280 + instructions16::Or { dest: modrm.effective(), src: modrm.register().into() }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 280 - instructions16::Or { dest: modrm.effective().into(), src: modrm.register().into() }.into(), [INFO] [stdout] 280 + instructions16::Or { dest: as Into<_>>::into(modrm.effective()), src: modrm.register().into() }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:282:43 [INFO] [stdout] | [INFO] [stdout] 282 | instructions8::Or { dest: modrm.register().into(), src: modrm.effective().into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 282 - instructions8::Or { dest: modrm.register().into(), src: modrm.effective().into() }.into(), [INFO] [stdout] 282 + instructions8::Or { dest: modrm.register(), src: modrm.effective().into() }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 282 - instructions8::Or { dest: modrm.register().into(), src: modrm.effective().into() }.into(), [INFO] [stdout] 282 + instructions8::Or { dest: as Into<_>>::into(modrm.register()), src: modrm.effective().into() }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stderr] error: could not compile `emulator` (bin "emulator" test) due to 97 previous errors; 4 warnings emitted [INFO] [stderr] warning: build failed, waiting for other jobs to finish... [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:284:44 [INFO] [stdout] | [INFO] [stdout] 284 | instructions16::Or { dest: modrm.register().into(), src: modrm.effective().into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 284 - instructions16::Or { dest: modrm.register().into(), src: modrm.effective().into() }.into(), [INFO] [stdout] 284 + instructions16::Or { dest: modrm.register(), src: modrm.effective().into() }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 284 - instructions16::Or { dest: modrm.register().into(), src: modrm.effective().into() }.into(), [INFO] [stdout] 284 + instructions16::Or { dest: as Into<_>>::into(modrm.register()), src: modrm.effective().into() }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:292:44 [INFO] [stdout] | [INFO] [stdout] 292 | instructions8::Adc { dest: modrm.effective().into(), src: modrm.register().into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 292 - instructions8::Adc { dest: modrm.effective().into(), src: modrm.register().into() }.into(), [INFO] [stdout] 292 + instructions8::Adc { dest: modrm.effective(), src: modrm.register().into() }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 292 - instructions8::Adc { dest: modrm.effective().into(), src: modrm.register().into() }.into(), [INFO] [stdout] 292 + instructions8::Adc { dest: as Into<_>>::into(modrm.effective()), src: modrm.register().into() }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:294:45 [INFO] [stdout] | [INFO] [stdout] 294 | instructions16::Adc { dest: modrm.effective().into(), src: modrm.register().into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 294 - instructions16::Adc { dest: modrm.effective().into(), src: modrm.register().into() }.into(), [INFO] [stdout] 294 + instructions16::Adc { dest: modrm.effective(), src: modrm.register().into() }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 294 - instructions16::Adc { dest: modrm.effective().into(), src: modrm.register().into() }.into(), [INFO] [stdout] 294 + instructions16::Adc { dest: as Into<_>>::into(modrm.effective()), src: modrm.register().into() }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:296:44 [INFO] [stdout] | [INFO] [stdout] 296 | instructions8::Adc { dest: modrm.register().into(), src: modrm.effective().into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 296 - instructions8::Adc { dest: modrm.register().into(), src: modrm.effective().into() }.into(), [INFO] [stdout] 296 + instructions8::Adc { dest: modrm.register(), src: modrm.effective().into() }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 296 - instructions8::Adc { dest: modrm.register().into(), src: modrm.effective().into() }.into(), [INFO] [stdout] 296 + instructions8::Adc { dest: as Into<_>>::into(modrm.register()), src: modrm.effective().into() }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:298:45 [INFO] [stdout] | [INFO] [stdout] 298 | instructions16::Adc { dest: modrm.register().into(), src: modrm.effective().into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 298 - instructions16::Adc { dest: modrm.register().into(), src: modrm.effective().into() }.into(), [INFO] [stdout] 298 + instructions16::Adc { dest: modrm.register(), src: modrm.effective().into() }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 298 - instructions16::Adc { dest: modrm.register().into(), src: modrm.effective().into() }.into(), [INFO] [stdout] 298 + instructions16::Adc { dest: as Into<_>>::into(modrm.register()), src: modrm.effective().into() }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:308:44 [INFO] [stdout] | [INFO] [stdout] 308 | instructions8::Sbb { dest: modrm.effective().into(), src: modrm.register().into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 308 - instructions8::Sbb { dest: modrm.effective().into(), src: modrm.register().into() }.into(), [INFO] [stdout] 308 + instructions8::Sbb { dest: modrm.effective(), src: modrm.register().into() }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 308 - instructions8::Sbb { dest: modrm.effective().into(), src: modrm.register().into() }.into(), [INFO] [stdout] 308 + instructions8::Sbb { dest: as Into<_>>::into(modrm.effective()), src: modrm.register().into() }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:310:45 [INFO] [stdout] | [INFO] [stdout] 310 | instructions16::Sbb { dest: modrm.effective().into(), src: modrm.register().into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 310 - instructions16::Sbb { dest: modrm.effective().into(), src: modrm.register().into() }.into(), [INFO] [stdout] 310 + instructions16::Sbb { dest: modrm.effective(), src: modrm.register().into() }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 310 - instructions16::Sbb { dest: modrm.effective().into(), src: modrm.register().into() }.into(), [INFO] [stdout] 310 + instructions16::Sbb { dest: as Into<_>>::into(modrm.effective()), src: modrm.register().into() }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:312:44 [INFO] [stdout] | [INFO] [stdout] 312 | instructions8::Sbb { dest: modrm.register().into(), src: modrm.effective().into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 312 - instructions8::Sbb { dest: modrm.register().into(), src: modrm.effective().into() }.into(), [INFO] [stdout] 312 + instructions8::Sbb { dest: modrm.register(), src: modrm.effective().into() }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 312 - instructions8::Sbb { dest: modrm.register().into(), src: modrm.effective().into() }.into(), [INFO] [stdout] 312 + instructions8::Sbb { dest: as Into<_>>::into(modrm.register()), src: modrm.effective().into() }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:314:45 [INFO] [stdout] | [INFO] [stdout] 314 | instructions16::Sbb { dest: modrm.register().into(), src: modrm.effective().into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 314 - instructions16::Sbb { dest: modrm.register().into(), src: modrm.effective().into() }.into(), [INFO] [stdout] 314 + instructions16::Sbb { dest: modrm.register(), src: modrm.effective().into() }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 314 - instructions16::Sbb { dest: modrm.register().into(), src: modrm.effective().into() }.into(), [INFO] [stdout] 314 + instructions16::Sbb { dest: as Into<_>>::into(modrm.register()), src: modrm.effective().into() }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:324:44 [INFO] [stdout] | [INFO] [stdout] 324 | instructions8::And { dest: modrm.effective().into(), src: modrm.register().into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 324 - instructions8::And { dest: modrm.effective().into(), src: modrm.register().into() }.into(), [INFO] [stdout] 324 + instructions8::And { dest: modrm.effective(), src: modrm.register().into() }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 324 - instructions8::And { dest: modrm.effective().into(), src: modrm.register().into() }.into(), [INFO] [stdout] 324 + instructions8::And { dest: as Into<_>>::into(modrm.effective()), src: modrm.register().into() }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:326:45 [INFO] [stdout] | [INFO] [stdout] 326 | instructions16::And { dest: modrm.effective().into(), src: modrm.register().into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 326 - instructions16::And { dest: modrm.effective().into(), src: modrm.register().into() }.into(), [INFO] [stdout] 326 + instructions16::And { dest: modrm.effective(), src: modrm.register().into() }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 326 - instructions16::And { dest: modrm.effective().into(), src: modrm.register().into() }.into(), [INFO] [stdout] 326 + instructions16::And { dest: as Into<_>>::into(modrm.effective()), src: modrm.register().into() }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:328:44 [INFO] [stdout] | [INFO] [stdout] 328 | instructions8::And { dest: modrm.register().into(), src: modrm.effective().into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 328 - instructions8::And { dest: modrm.register().into(), src: modrm.effective().into() }.into(), [INFO] [stdout] 328 + instructions8::And { dest: modrm.register(), src: modrm.effective().into() }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 328 - instructions8::And { dest: modrm.register().into(), src: modrm.effective().into() }.into(), [INFO] [stdout] 328 + instructions8::And { dest: as Into<_>>::into(modrm.register()), src: modrm.effective().into() }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:330:45 [INFO] [stdout] | [INFO] [stdout] 330 | instructions16::And { dest: modrm.register().into(), src: modrm.effective().into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 330 - instructions16::And { dest: modrm.register().into(), src: modrm.effective().into() }.into(), [INFO] [stdout] 330 + instructions16::And { dest: modrm.register(), src: modrm.effective().into() }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 330 - instructions16::And { dest: modrm.register().into(), src: modrm.effective().into() }.into(), [INFO] [stdout] 330 + instructions16::And { dest: as Into<_>>::into(modrm.register()), src: modrm.effective().into() }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:337:44 [INFO] [stdout] | [INFO] [stdout] 337 | instructions8::Sub { dest: modrm.effective().into(), src: modrm.register().into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 337 - instructions8::Sub { dest: modrm.effective().into(), src: modrm.register().into() }.into(), [INFO] [stdout] 337 + instructions8::Sub { dest: modrm.effective(), src: modrm.register().into() }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 337 - instructions8::Sub { dest: modrm.effective().into(), src: modrm.register().into() }.into(), [INFO] [stdout] 337 + instructions8::Sub { dest: as Into<_>>::into(modrm.effective()), src: modrm.register().into() }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:339:45 [INFO] [stdout] | [INFO] [stdout] 339 | instructions16::Sub { dest: modrm.effective().into(), src: modrm.register().into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 339 - instructions16::Sub { dest: modrm.effective().into(), src: modrm.register().into() }.into(), [INFO] [stdout] 339 + instructions16::Sub { dest: modrm.effective(), src: modrm.register().into() }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 339 - instructions16::Sub { dest: modrm.effective().into(), src: modrm.register().into() }.into(), [INFO] [stdout] 339 + instructions16::Sub { dest: as Into<_>>::into(modrm.effective()), src: modrm.register().into() }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:341:44 [INFO] [stdout] | [INFO] [stdout] 341 | instructions8::Sub { dest: modrm.register().into(), src: modrm.effective().into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 341 - instructions8::Sub { dest: modrm.register().into(), src: modrm.effective().into() }.into(), [INFO] [stdout] 341 + instructions8::Sub { dest: modrm.register(), src: modrm.effective().into() }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 341 - instructions8::Sub { dest: modrm.register().into(), src: modrm.effective().into() }.into(), [INFO] [stdout] 341 + instructions8::Sub { dest: as Into<_>>::into(modrm.register()), src: modrm.effective().into() }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:343:45 [INFO] [stdout] | [INFO] [stdout] 343 | instructions16::Sub { dest: modrm.register().into(), src: modrm.effective().into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 343 - instructions16::Sub { dest: modrm.register().into(), src: modrm.effective().into() }.into(), [INFO] [stdout] 343 + instructions16::Sub { dest: modrm.register(), src: modrm.effective().into() }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 343 - instructions16::Sub { dest: modrm.register().into(), src: modrm.effective().into() }.into(), [INFO] [stdout] 343 + instructions16::Sub { dest: as Into<_>>::into(modrm.register()), src: modrm.effective().into() }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:350:44 [INFO] [stdout] | [INFO] [stdout] 350 | instructions8::Xor { dest: modrm.effective().into(), src: modrm.register().into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 350 - instructions8::Xor { dest: modrm.effective().into(), src: modrm.register().into() }.into(), [INFO] [stdout] 350 + instructions8::Xor { dest: modrm.effective(), src: modrm.register().into() }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 350 - instructions8::Xor { dest: modrm.effective().into(), src: modrm.register().into() }.into(), [INFO] [stdout] 350 + instructions8::Xor { dest: as Into<_>>::into(modrm.effective()), src: modrm.register().into() }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:352:45 [INFO] [stdout] | [INFO] [stdout] 352 | instructions16::Xor { dest: modrm.effective().into(), src: modrm.register().into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 352 - instructions16::Xor { dest: modrm.effective().into(), src: modrm.register().into() }.into(), [INFO] [stdout] 352 + instructions16::Xor { dest: modrm.effective(), src: modrm.register().into() }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 352 - instructions16::Xor { dest: modrm.effective().into(), src: modrm.register().into() }.into(), [INFO] [stdout] 352 + instructions16::Xor { dest: as Into<_>>::into(modrm.effective()), src: modrm.register().into() }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:354:44 [INFO] [stdout] | [INFO] [stdout] 354 | instructions8::Xor { dest: modrm.register().into(), src: modrm.effective().into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 354 - instructions8::Xor { dest: modrm.register().into(), src: modrm.effective().into() }.into(), [INFO] [stdout] 354 + instructions8::Xor { dest: modrm.register(), src: modrm.effective().into() }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 354 - instructions8::Xor { dest: modrm.register().into(), src: modrm.effective().into() }.into(), [INFO] [stdout] 354 + instructions8::Xor { dest: as Into<_>>::into(modrm.register()), src: modrm.effective().into() }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:356:45 [INFO] [stdout] | [INFO] [stdout] 356 | instructions16::Xor { dest: modrm.register().into(), src: modrm.effective().into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 356 - instructions16::Xor { dest: modrm.register().into(), src: modrm.effective().into() }.into(), [INFO] [stdout] 356 + instructions16::Xor { dest: modrm.register(), src: modrm.effective().into() }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 356 - instructions16::Xor { dest: modrm.register().into(), src: modrm.effective().into() }.into(), [INFO] [stdout] 356 + instructions16::Xor { dest: as Into<_>>::into(modrm.register()), src: modrm.effective().into() }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:378:44 [INFO] [stdout] | [INFO] [stdout] 378 | instructions::Arpl { dest: modrm.effective().into(), src: modrm.register().into() } .into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 378 - instructions::Arpl { dest: modrm.effective().into(), src: modrm.register().into() } .into(), [INFO] [stdout] 378 + instructions::Arpl { dest: modrm.effective(), src: modrm.register().into() } .into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 378 - instructions::Arpl { dest: modrm.effective().into(), src: modrm.register().into() } .into(), [INFO] [stdout] 378 + instructions::Arpl { dest: as Into<_>>::into(modrm.effective()), src: modrm.register().into() } .into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:382:24 [INFO] [stdout] | [INFO] [stdout] 382 | dest1: modrm.register().into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 382 - dest1: modrm.register().into(), [INFO] [stdout] 382 + dest1: modrm.register(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 382 - dest1: modrm.register().into(), [INFO] [stdout] 382 + dest1: as Into<_>>::into(modrm.register()), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:388:24 [INFO] [stdout] | [INFO] [stdout] 388 | dest1: modrm.register().into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 388 - dest1: modrm.register().into(), [INFO] [stdout] 388 + dest1: modrm.register(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 388 - dest1: modrm.register().into(), [INFO] [stdout] 388 + dest1: as Into<_>>::into(modrm.register()), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `i8` [INFO] [stdout] --> src/disasm/decoder.rs:397:45 [INFO] [stdout] | [INFO] [stdout] 397 | instructions8::Jo { offset: offset.into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 397 - instructions8::Jo { offset: offset.into() }.into(), [INFO] [stdout] 397 + instructions8::Jo { offset: offset }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 397 - instructions8::Jo { offset: offset.into() }.into(), [INFO] [stdout] 397 + instructions8::Jo { offset: >::into(offset) }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `i8` [INFO] [stdout] --> src/disasm/decoder.rs:399:46 [INFO] [stdout] | [INFO] [stdout] 399 | instructions8::Jno { offset: offset.into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 399 - instructions8::Jno { offset: offset.into() }.into(), [INFO] [stdout] 399 + instructions8::Jno { offset: offset }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 399 - instructions8::Jno { offset: offset.into() }.into(), [INFO] [stdout] 399 + instructions8::Jno { offset: >::into(offset) }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `i8` [INFO] [stdout] --> src/disasm/decoder.rs:401:45 [INFO] [stdout] | [INFO] [stdout] 401 | instructions8::Jb { offset: offset.into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 401 - instructions8::Jb { offset: offset.into() }.into(), [INFO] [stdout] 401 + instructions8::Jb { offset: offset }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 401 - instructions8::Jb { offset: offset.into() }.into(), [INFO] [stdout] 401 + instructions8::Jb { offset: >::into(offset) }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `i8` [INFO] [stdout] --> src/disasm/decoder.rs:403:46 [INFO] [stdout] | [INFO] [stdout] 403 | instructions8::Jae { offset: offset.into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 403 - instructions8::Jae { offset: offset.into() }.into(), [INFO] [stdout] 403 + instructions8::Jae { offset: offset }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 403 - instructions8::Jae { offset: offset.into() }.into(), [INFO] [stdout] 403 + instructions8::Jae { offset: >::into(offset) }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `i8` [INFO] [stdout] --> src/disasm/decoder.rs:405:45 [INFO] [stdout] | [INFO] [stdout] 405 | instructions8::Je { offset: offset.into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 405 - instructions8::Je { offset: offset.into() }.into(), [INFO] [stdout] 405 + instructions8::Je { offset: offset }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 405 - instructions8::Je { offset: offset.into() }.into(), [INFO] [stdout] 405 + instructions8::Je { offset: >::into(offset) }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `i8` [INFO] [stdout] --> src/disasm/decoder.rs:407:46 [INFO] [stdout] | [INFO] [stdout] 407 | instructions8::Jne { offset: offset.into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 407 - instructions8::Jne { offset: offset.into() }.into(), [INFO] [stdout] 407 + instructions8::Jne { offset: offset }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 407 - instructions8::Jne { offset: offset.into() }.into(), [INFO] [stdout] 407 + instructions8::Jne { offset: >::into(offset) }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `i8` [INFO] [stdout] --> src/disasm/decoder.rs:409:46 [INFO] [stdout] | [INFO] [stdout] 409 | instructions8::Jbe { offset: offset.into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 409 - instructions8::Jbe { offset: offset.into() }.into(), [INFO] [stdout] 409 + instructions8::Jbe { offset: offset }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 409 - instructions8::Jbe { offset: offset.into() }.into(), [INFO] [stdout] 409 + instructions8::Jbe { offset: >::into(offset) }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `i8` [INFO] [stdout] --> src/disasm/decoder.rs:411:45 [INFO] [stdout] | [INFO] [stdout] 411 | instructions8::Ja { offset: offset.into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 411 - instructions8::Ja { offset: offset.into() }.into(), [INFO] [stdout] 411 + instructions8::Ja { offset: offset }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 411 - instructions8::Ja { offset: offset.into() }.into(), [INFO] [stdout] 411 + instructions8::Ja { offset: >::into(offset) }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `i8` [INFO] [stdout] --> src/disasm/decoder.rs:413:45 [INFO] [stdout] | [INFO] [stdout] 413 | instructions8::Js { offset: offset.into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 413 - instructions8::Js { offset: offset.into() }.into(), [INFO] [stdout] 413 + instructions8::Js { offset: offset }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 413 - instructions8::Js { offset: offset.into() }.into(), [INFO] [stdout] 413 + instructions8::Js { offset: >::into(offset) }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `i8` [INFO] [stdout] --> src/disasm/decoder.rs:415:46 [INFO] [stdout] | [INFO] [stdout] 415 | instructions8::Jns { offset: offset.into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 415 - instructions8::Jns { offset: offset.into() }.into(), [INFO] [stdout] 415 + instructions8::Jns { offset: offset }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 415 - instructions8::Jns { offset: offset.into() }.into(), [INFO] [stdout] 415 + instructions8::Jns { offset: >::into(offset) }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `i8` [INFO] [stdout] --> src/disasm/decoder.rs:417:45 [INFO] [stdout] | [INFO] [stdout] 417 | instructions8::Jp { offset: offset.into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 417 - instructions8::Jp { offset: offset.into() }.into(), [INFO] [stdout] 417 + instructions8::Jp { offset: offset }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 417 - instructions8::Jp { offset: offset.into() }.into(), [INFO] [stdout] 417 + instructions8::Jp { offset: >::into(offset) }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `i8` [INFO] [stdout] --> src/disasm/decoder.rs:419:46 [INFO] [stdout] | [INFO] [stdout] 419 | instructions8::Jnp { offset: offset.into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 419 - instructions8::Jnp { offset: offset.into() }.into(), [INFO] [stdout] 419 + instructions8::Jnp { offset: offset }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 419 - instructions8::Jnp { offset: offset.into() }.into(), [INFO] [stdout] 419 + instructions8::Jnp { offset: >::into(offset) }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `i8` [INFO] [stdout] --> src/disasm/decoder.rs:421:45 [INFO] [stdout] | [INFO] [stdout] 421 | instructions8::Jl { offset: offset.into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 421 - instructions8::Jl { offset: offset.into() }.into(), [INFO] [stdout] 421 + instructions8::Jl { offset: offset }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 421 - instructions8::Jl { offset: offset.into() }.into(), [INFO] [stdout] 421 + instructions8::Jl { offset: >::into(offset) }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `i8` [INFO] [stdout] --> src/disasm/decoder.rs:423:46 [INFO] [stdout] | [INFO] [stdout] 423 | instructions8::Jge { offset: offset.into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 423 - instructions8::Jge { offset: offset.into() }.into(), [INFO] [stdout] 423 + instructions8::Jge { offset: offset }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 423 - instructions8::Jge { offset: offset.into() }.into(), [INFO] [stdout] 423 + instructions8::Jge { offset: >::into(offset) }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `i8` [INFO] [stdout] --> src/disasm/decoder.rs:425:46 [INFO] [stdout] | [INFO] [stdout] 425 | instructions8::Jle { offset: offset.into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 425 - instructions8::Jle { offset: offset.into() }.into(), [INFO] [stdout] 425 + instructions8::Jle { offset: offset }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 425 - instructions8::Jle { offset: offset.into() }.into(), [INFO] [stdout] 425 + instructions8::Jle { offset: >::into(offset) }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `i8` [INFO] [stdout] --> src/disasm/decoder.rs:427:45 [INFO] [stdout] | [INFO] [stdout] 427 | instructions8::Jg { offset: offset.into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 427 - instructions8::Jg { offset: offset.into() }.into(), [INFO] [stdout] 427 + instructions8::Jg { offset: offset }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 427 - instructions8::Jg { offset: offset.into() }.into(), [INFO] [stdout] 427 + instructions8::Jg { offset: >::into(offset) }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:433:42 [INFO] [stdout] | [INFO] [stdout] 433 | instructions8::Xchg { a: modrm.effective().into(), b: modrm.register().into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 433 - instructions8::Xchg { a: modrm.effective().into(), b: modrm.register().into() }.into(), [INFO] [stdout] 433 + instructions8::Xchg { a: modrm.effective(), b: modrm.register().into() }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 433 - instructions8::Xchg { a: modrm.effective().into(), b: modrm.register().into() }.into(), [INFO] [stdout] 433 + instructions8::Xchg { a: as Into<_>>::into(modrm.effective()), b: modrm.register().into() }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:433:71 [INFO] [stdout] | [INFO] [stdout] 433 | instructions8::Xchg { a: modrm.effective().into(), b: modrm.register().into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 433 - instructions8::Xchg { a: modrm.effective().into(), b: modrm.register().into() }.into(), [INFO] [stdout] 433 + instructions8::Xchg { a: modrm.effective().into(), b: modrm.register() }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 433 - instructions8::Xchg { a: modrm.effective().into(), b: modrm.register().into() }.into(), [INFO] [stdout] 433 + instructions8::Xchg { a: modrm.effective().into(), b: as Into<_>>::into(modrm.register()) }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:435:43 [INFO] [stdout] | [INFO] [stdout] 435 | instructions16::Xchg { a: modrm.effective().into(), b: modrm.register().into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 435 - instructions16::Xchg { a: modrm.effective().into(), b: modrm.register().into() }.into(), [INFO] [stdout] 435 + instructions16::Xchg { a: modrm.effective(), b: modrm.register().into() }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 435 - instructions16::Xchg { a: modrm.effective().into(), b: modrm.register().into() }.into(), [INFO] [stdout] 435 + instructions16::Xchg { a: as Into<_>>::into(modrm.effective()), b: modrm.register().into() }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:435:72 [INFO] [stdout] | [INFO] [stdout] 435 | instructions16::Xchg { a: modrm.effective().into(), b: modrm.register().into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 435 - instructions16::Xchg { a: modrm.effective().into(), b: modrm.register().into() }.into(), [INFO] [stdout] 435 + instructions16::Xchg { a: modrm.effective().into(), b: modrm.register() }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 435 - instructions16::Xchg { a: modrm.effective().into(), b: modrm.register().into() }.into(), [INFO] [stdout] 435 + instructions16::Xchg { a: modrm.effective().into(), b: as Into<_>>::into(modrm.register()) }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:437:44 [INFO] [stdout] | [INFO] [stdout] 437 | instructions8::Mov { dest: modrm.effective().into(), src: modrm.register().into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 437 - instructions8::Mov { dest: modrm.effective().into(), src: modrm.register().into() }.into(), [INFO] [stdout] 437 + instructions8::Mov { dest: modrm.effective(), src: modrm.register().into() }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 437 - instructions8::Mov { dest: modrm.effective().into(), src: modrm.register().into() }.into(), [INFO] [stdout] 437 + instructions8::Mov { dest: as Into<_>>::into(modrm.effective()), src: modrm.register().into() }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:439:45 [INFO] [stdout] | [INFO] [stdout] 439 | instructions16::Mov { dest: modrm.effective().into(), src: modrm.register().into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 439 - instructions16::Mov { dest: modrm.effective().into(), src: modrm.register().into() }.into(), [INFO] [stdout] 439 + instructions16::Mov { dest: modrm.effective(), src: modrm.register().into() }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 439 - instructions16::Mov { dest: modrm.effective().into(), src: modrm.register().into() }.into(), [INFO] [stdout] 439 + instructions16::Mov { dest: as Into<_>>::into(modrm.effective()), src: modrm.register().into() }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:441:44 [INFO] [stdout] | [INFO] [stdout] 441 | instructions8::Mov { dest: modrm.register().into(), src: modrm.effective().into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 441 - instructions8::Mov { dest: modrm.register().into(), src: modrm.effective().into() }.into(), [INFO] [stdout] 441 + instructions8::Mov { dest: modrm.register(), src: modrm.effective().into() }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 441 - instructions8::Mov { dest: modrm.register().into(), src: modrm.effective().into() }.into(), [INFO] [stdout] 441 + instructions8::Mov { dest: as Into<_>>::into(modrm.register()), src: modrm.effective().into() }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:443:45 [INFO] [stdout] | [INFO] [stdout] 443 | instructions16::Mov { dest: modrm.register().into(), src: modrm.effective().into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 443 - instructions16::Mov { dest: modrm.register().into(), src: modrm.effective().into() }.into(), [INFO] [stdout] 443 + instructions16::Mov { dest: modrm.register(), src: modrm.effective().into() }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 443 - instructions16::Mov { dest: modrm.register().into(), src: modrm.effective().into() }.into(), [INFO] [stdout] 443 + instructions16::Mov { dest: as Into<_>>::into(modrm.register()), src: modrm.effective().into() }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:445:45 [INFO] [stdout] | [INFO] [stdout] 445 | instructions16::Mov { dest: modrm.effective().into(), src: modrm.segment_register()?.into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 445 - instructions16::Mov { dest: modrm.effective().into(), src: modrm.segment_register()?.into() }.into(), [INFO] [stdout] 445 + instructions16::Mov { dest: modrm.effective(), src: modrm.segment_register()?.into() }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 445 - instructions16::Mov { dest: modrm.effective().into(), src: modrm.segment_register()?.into() }.into(), [INFO] [stdout] 445 + instructions16::Mov { dest: as Into<_>>::into(modrm.effective()), src: modrm.segment_register()?.into() }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:446:64 [INFO] [stdout] | [INFO] [stdout] 446 | [0x8D, modrm @ ModRM] => instructions::Lea { dest: modrm.register().into(), src: modrm.memory()? }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 446 - [0x8D, modrm @ ModRM] => instructions::Lea { dest: modrm.register().into(), src: modrm.memory()? }.into(), [INFO] [stdout] 446 + [0x8D, modrm @ ModRM] => instructions::Lea { dest: modrm.register(), src: modrm.memory()? }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 446 - [0x8D, modrm @ ModRM] => instructions::Lea { dest: modrm.register().into(), src: modrm.memory()? }.into(), [INFO] [stdout] 446 + [0x8D, modrm @ ModRM] => instructions::Lea { dest: as Into<_>>::into(modrm.register()), src: modrm.memory()? }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:448:45 [INFO] [stdout] | [INFO] [stdout] 448 | instructions16::Mov { dest: modrm.segment_register()?.into(), src: modrm.effective().into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 448 - instructions16::Mov { dest: modrm.segment_register()?.into(), src: modrm.effective().into() }.into(), [INFO] [stdout] 448 + instructions16::Mov { dest: modrm.segment_register()?, src: modrm.effective().into() }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 448 - instructions16::Mov { dest: modrm.segment_register()?.into(), src: modrm.effective().into() }.into(), [INFO] [stdout] 448 + instructions16::Mov { dest: as Into<_>>::into(modrm.segment_register()?), src: modrm.effective().into() }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:450:45 [INFO] [stdout] | [INFO] [stdout] 450 | instructions16::Pop { dest: modrm.effective().into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 450 - instructions16::Pop { dest: modrm.effective().into() }.into(), [INFO] [stdout] 450 + instructions16::Pop { dest: modrm.effective() }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 450 - instructions16::Pop { dest: modrm.effective().into() }.into(), [INFO] [stdout] 450 + instructions16::Pop { dest: as Into<_>>::into(modrm.effective()) }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u16` [INFO] [stdout] --> src/disasm/decoder.rs:484:48 [INFO] [stdout] | [INFO] [stdout] 484 | instructions::RetNear { count: count.into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 484 - instructions::RetNear { count: count.into() }.into(), [INFO] [stdout] 484 + instructions::RetNear { count: count }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 484 - instructions::RetNear { count: count.into() }.into(), [INFO] [stdout] 484 + instructions::RetNear { count: >::into(count) }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:487:43 [INFO] [stdout] | [INFO] [stdout] 487 | instructions::Les { dest: modrm.register().into(), src: modrm.memory()?.into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 487 - instructions::Les { dest: modrm.register().into(), src: modrm.memory()?.into() }.into(), [INFO] [stdout] 487 + instructions::Les { dest: modrm.register(), src: modrm.memory()?.into() }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 487 - instructions::Les { dest: modrm.register().into(), src: modrm.memory()?.into() }.into(), [INFO] [stdout] 487 + instructions::Les { dest: as Into<_>>::into(modrm.register()), src: modrm.memory()?.into() }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:489:43 [INFO] [stdout] | [INFO] [stdout] 489 | instructions::Lds { dest: modrm.register().into(), src: modrm.memory()?.into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 489 - instructions::Lds { dest: modrm.register().into(), src: modrm.memory()?.into() }.into(), [INFO] [stdout] 489 + instructions::Lds { dest: modrm.register(), src: modrm.memory()?.into() }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 489 - instructions::Lds { dest: modrm.register().into(), src: modrm.memory()?.into() }.into(), [INFO] [stdout] 489 + instructions::Lds { dest: as Into<_>>::into(modrm.register()), src: modrm.memory()?.into() }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:491:44 [INFO] [stdout] | [INFO] [stdout] 491 | instructions8::Mov { dest: modrm.effective().into(), src: src.into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 491 - instructions8::Mov { dest: modrm.effective().into(), src: src.into() }.into(), [INFO] [stdout] 491 + instructions8::Mov { dest: modrm.effective(), src: src.into() }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 491 - instructions8::Mov { dest: modrm.effective().into(), src: src.into() }.into(), [INFO] [stdout] 491 + instructions8::Mov { dest: as Into<_>>::into(modrm.effective()), src: src.into() }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:493:45 [INFO] [stdout] | [INFO] [stdout] 493 | instructions16::Mov { dest: modrm.effective().into(), src: src.into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 493 - instructions16::Mov { dest: modrm.effective().into(), src: src.into() }.into(), [INFO] [stdout] 493 + instructions16::Mov { dest: modrm.effective(), src: src.into() }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 493 - instructions16::Mov { dest: modrm.effective().into(), src: src.into() }.into(), [INFO] [stdout] 493 + instructions16::Mov { dest: as Into<_>>::into(modrm.effective()), src: src.into() }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u16` [INFO] [stdout] --> src/disasm/decoder.rs:495:47 [INFO] [stdout] | [INFO] [stdout] 495 | instructions::RetFar { count: count.into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 495 - instructions::RetFar { count: count.into() }.into(), [INFO] [stdout] 495 + instructions::RetFar { count: count }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 495 - instructions::RetFar { count: count.into() }.into(), [INFO] [stdout] 495 + instructions::RetFar { count: >::into(count) }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `i8` [INFO] [stdout] --> src/disasm/decoder.rs:509:47 [INFO] [stdout] | [INFO] [stdout] 509 | instructions::Loope { offset: offset.into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 509 - instructions::Loope { offset: offset.into() }.into(), [INFO] [stdout] 509 + instructions::Loope { offset: offset }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 509 - instructions::Loope { offset: offset.into() }.into(), [INFO] [stdout] 509 + instructions::Loope { offset: >::into(offset) }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `i8` [INFO] [stdout] --> src/disasm/decoder.rs:511:46 [INFO] [stdout] | [INFO] [stdout] 511 | instructions::Loop { offset: offset.into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 511 - instructions::Loop { offset: offset.into() }.into(), [INFO] [stdout] 511 + instructions::Loop { offset: offset }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 511 - instructions::Loop { offset: offset.into() }.into(), [INFO] [stdout] 511 + instructions::Loop { offset: >::into(offset) }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `i8` [INFO] [stdout] --> src/disasm/decoder.rs:513:46 [INFO] [stdout] | [INFO] [stdout] 513 | instructions::Jcxz { offset: offset.into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 513 - instructions::Jcxz { offset: offset.into() }.into(), [INFO] [stdout] 513 + instructions::Jcxz { offset: offset }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 513 - instructions::Jcxz { offset: offset.into() }.into(), [INFO] [stdout] 513 + instructions::Jcxz { offset: >::into(offset) }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `i16` [INFO] [stdout] --> src/disasm/decoder.rs:523:49 [INFO] [stdout] | [INFO] [stdout] 523 | instructions::CallRel { offset: offset.into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 523 - instructions::CallRel { offset: offset.into() }.into(), [INFO] [stdout] 523 + instructions::CallRel { offset: offset }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 523 - instructions::CallRel { offset: offset.into() }.into(), [INFO] [stdout] 523 + instructions::CallRel { offset: >::into(offset) }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `i16` [INFO] [stdout] --> src/disasm/decoder.rs:525:50 [INFO] [stdout] | [INFO] [stdout] 525 | instructions16::JmpRel { offset: offset.into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 525 - instructions16::JmpRel { offset: offset.into() }.into(), [INFO] [stdout] 525 + instructions16::JmpRel { offset: offset }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 525 - instructions16::JmpRel { offset: offset.into() }.into(), [INFO] [stdout] 525 + instructions16::JmpRel { offset: >::into(offset) }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `i8` [INFO] [stdout] --> src/disasm/decoder.rs:529:49 [INFO] [stdout] | [INFO] [stdout] 529 | instructions8::JmpRel { offset: offset.into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 529 - instructions8::JmpRel { offset: offset.into() }.into(), [INFO] [stdout] 529 + instructions8::JmpRel { offset: offset }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 529 - instructions8::JmpRel { offset: offset.into() }.into(), [INFO] [stdout] 529 + instructions8::JmpRel { offset: >::into(offset) }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `i16` [INFO] [stdout] --> src/disasm/decoder.rs:554:66 [INFO] [stdout] | [INFO] [stdout] 554 | [0x80, offset @ i16] => instructions16::Jo { offset: offset.into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 554 - [0x80, offset @ i16] => instructions16::Jo { offset: offset.into() }.into(), [INFO] [stdout] 554 + [0x80, offset @ i16] => instructions16::Jo { offset: offset }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 554 - [0x80, offset @ i16] => instructions16::Jo { offset: offset.into() }.into(), [INFO] [stdout] 554 + [0x80, offset @ i16] => instructions16::Jo { offset: >::into(offset) }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `i16` [INFO] [stdout] --> src/disasm/decoder.rs:555:67 [INFO] [stdout] | [INFO] [stdout] 555 | [0x81, offset @ i16] => instructions16::Jno { offset: offset.into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 555 - [0x81, offset @ i16] => instructions16::Jno { offset: offset.into() }.into(), [INFO] [stdout] 555 + [0x81, offset @ i16] => instructions16::Jno { offset: offset }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 555 - [0x81, offset @ i16] => instructions16::Jno { offset: offset.into() }.into(), [INFO] [stdout] 555 + [0x81, offset @ i16] => instructions16::Jno { offset: >::into(offset) }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `i16` [INFO] [stdout] --> src/disasm/decoder.rs:556:66 [INFO] [stdout] | [INFO] [stdout] 556 | [0x82, offset @ i16] => instructions16::Jb { offset: offset.into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 556 - [0x82, offset @ i16] => instructions16::Jb { offset: offset.into() }.into(), [INFO] [stdout] 556 + [0x82, offset @ i16] => instructions16::Jb { offset: offset }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 556 - [0x82, offset @ i16] => instructions16::Jb { offset: offset.into() }.into(), [INFO] [stdout] 556 + [0x82, offset @ i16] => instructions16::Jb { offset: >::into(offset) }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `i16` [INFO] [stdout] --> src/disasm/decoder.rs:557:67 [INFO] [stdout] | [INFO] [stdout] 557 | [0x83, offset @ i16] => instructions16::Jae { offset: offset.into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 557 - [0x83, offset @ i16] => instructions16::Jae { offset: offset.into() }.into(), [INFO] [stdout] 557 + [0x83, offset @ i16] => instructions16::Jae { offset: offset }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 557 - [0x83, offset @ i16] => instructions16::Jae { offset: offset.into() }.into(), [INFO] [stdout] 557 + [0x83, offset @ i16] => instructions16::Jae { offset: >::into(offset) }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `i16` [INFO] [stdout] --> src/disasm/decoder.rs:558:66 [INFO] [stdout] | [INFO] [stdout] 558 | [0x84, offset @ i16] => instructions16::Je { offset: offset.into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 558 - [0x84, offset @ i16] => instructions16::Je { offset: offset.into() }.into(), [INFO] [stdout] 558 + [0x84, offset @ i16] => instructions16::Je { offset: offset }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 558 - [0x84, offset @ i16] => instructions16::Je { offset: offset.into() }.into(), [INFO] [stdout] 558 + [0x84, offset @ i16] => instructions16::Je { offset: >::into(offset) }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `i16` [INFO] [stdout] --> src/disasm/decoder.rs:559:67 [INFO] [stdout] | [INFO] [stdout] 559 | [0x85, offset @ i16] => instructions16::Jne { offset: offset.into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 559 - [0x85, offset @ i16] => instructions16::Jne { offset: offset.into() }.into(), [INFO] [stdout] 559 + [0x85, offset @ i16] => instructions16::Jne { offset: offset }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 559 - [0x85, offset @ i16] => instructions16::Jne { offset: offset.into() }.into(), [INFO] [stdout] 559 + [0x85, offset @ i16] => instructions16::Jne { offset: >::into(offset) }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `i16` [INFO] [stdout] --> src/disasm/decoder.rs:560:67 [INFO] [stdout] | [INFO] [stdout] 560 | [0x86, offset @ i16] => instructions16::Jbe { offset: offset.into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 560 - [0x86, offset @ i16] => instructions16::Jbe { offset: offset.into() }.into(), [INFO] [stdout] 560 + [0x86, offset @ i16] => instructions16::Jbe { offset: offset }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 560 - [0x86, offset @ i16] => instructions16::Jbe { offset: offset.into() }.into(), [INFO] [stdout] 560 + [0x86, offset @ i16] => instructions16::Jbe { offset: >::into(offset) }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `i16` [INFO] [stdout] --> src/disasm/decoder.rs:561:66 [INFO] [stdout] | [INFO] [stdout] 561 | [0x87, offset @ i16] => instructions16::Ja { offset: offset.into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 561 - [0x87, offset @ i16] => instructions16::Ja { offset: offset.into() }.into(), [INFO] [stdout] 561 + [0x87, offset @ i16] => instructions16::Ja { offset: offset }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 561 - [0x87, offset @ i16] => instructions16::Ja { offset: offset.into() }.into(), [INFO] [stdout] 561 + [0x87, offset @ i16] => instructions16::Ja { offset: >::into(offset) }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `i16` [INFO] [stdout] --> src/disasm/decoder.rs:562:66 [INFO] [stdout] | [INFO] [stdout] 562 | [0x88, offset @ i16] => instructions16::Js { offset: offset.into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 562 - [0x88, offset @ i16] => instructions16::Js { offset: offset.into() }.into(), [INFO] [stdout] 562 + [0x88, offset @ i16] => instructions16::Js { offset: offset }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 562 - [0x88, offset @ i16] => instructions16::Js { offset: offset.into() }.into(), [INFO] [stdout] 562 + [0x88, offset @ i16] => instructions16::Js { offset: >::into(offset) }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `i16` [INFO] [stdout] --> src/disasm/decoder.rs:563:67 [INFO] [stdout] | [INFO] [stdout] 563 | [0x89, offset @ i16] => instructions16::Jns { offset: offset.into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 563 - [0x89, offset @ i16] => instructions16::Jns { offset: offset.into() }.into(), [INFO] [stdout] 563 + [0x89, offset @ i16] => instructions16::Jns { offset: offset }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 563 - [0x89, offset @ i16] => instructions16::Jns { offset: offset.into() }.into(), [INFO] [stdout] 563 + [0x89, offset @ i16] => instructions16::Jns { offset: >::into(offset) }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `i16` [INFO] [stdout] --> src/disasm/decoder.rs:564:66 [INFO] [stdout] | [INFO] [stdout] 564 | [0x8A, offset @ i16] => instructions16::Jp { offset: offset.into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 564 - [0x8A, offset @ i16] => instructions16::Jp { offset: offset.into() }.into(), [INFO] [stdout] 564 + [0x8A, offset @ i16] => instructions16::Jp { offset: offset }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 564 - [0x8A, offset @ i16] => instructions16::Jp { offset: offset.into() }.into(), [INFO] [stdout] 564 + [0x8A, offset @ i16] => instructions16::Jp { offset: >::into(offset) }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `i16` [INFO] [stdout] --> src/disasm/decoder.rs:565:67 [INFO] [stdout] | [INFO] [stdout] 565 | [0x8B, offset @ i16] => instructions16::Jnp { offset: offset.into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 565 - [0x8B, offset @ i16] => instructions16::Jnp { offset: offset.into() }.into(), [INFO] [stdout] 565 + [0x8B, offset @ i16] => instructions16::Jnp { offset: offset }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 565 - [0x8B, offset @ i16] => instructions16::Jnp { offset: offset.into() }.into(), [INFO] [stdout] 565 + [0x8B, offset @ i16] => instructions16::Jnp { offset: >::into(offset) }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `i16` [INFO] [stdout] --> src/disasm/decoder.rs:566:66 [INFO] [stdout] | [INFO] [stdout] 566 | [0x8C, offset @ i16] => instructions16::Jl { offset: offset.into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 566 - [0x8C, offset @ i16] => instructions16::Jl { offset: offset.into() }.into(), [INFO] [stdout] 566 + [0x8C, offset @ i16] => instructions16::Jl { offset: offset }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 566 - [0x8C, offset @ i16] => instructions16::Jl { offset: offset.into() }.into(), [INFO] [stdout] 566 + [0x8C, offset @ i16] => instructions16::Jl { offset: >::into(offset) }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `i16` [INFO] [stdout] --> src/disasm/decoder.rs:567:67 [INFO] [stdout] | [INFO] [stdout] 567 | [0x8D, offset @ i16] => instructions16::Jge { offset: offset.into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 567 - [0x8D, offset @ i16] => instructions16::Jge { offset: offset.into() }.into(), [INFO] [stdout] 567 + [0x8D, offset @ i16] => instructions16::Jge { offset: offset }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 567 - [0x8D, offset @ i16] => instructions16::Jge { offset: offset.into() }.into(), [INFO] [stdout] 567 + [0x8D, offset @ i16] => instructions16::Jge { offset: >::into(offset) }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `i16` [INFO] [stdout] --> src/disasm/decoder.rs:568:67 [INFO] [stdout] | [INFO] [stdout] 568 | [0x8E, offset @ i16] => instructions16::Jle { offset: offset.into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 568 - [0x8E, offset @ i16] => instructions16::Jle { offset: offset.into() }.into(), [INFO] [stdout] 568 + [0x8E, offset @ i16] => instructions16::Jle { offset: offset }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 568 - [0x8E, offset @ i16] => instructions16::Jle { offset: offset.into() }.into(), [INFO] [stdout] 568 + [0x8E, offset @ i16] => instructions16::Jle { offset: >::into(offset) }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `i16` [INFO] [stdout] --> src/disasm/decoder.rs:569:66 [INFO] [stdout] | [INFO] [stdout] 569 | [0x8F, offset @ i16] => instructions16::Jg { offset: offset.into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 569 - [0x8F, offset @ i16] => instructions16::Jg { offset: offset.into() }.into(), [INFO] [stdout] 569 + [0x8F, offset @ i16] => instructions16::Jg { offset: offset }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 569 - [0x8F, offset @ i16] => instructions16::Jg { offset: offset.into() }.into(), [INFO] [stdout] 569 + [0x8F, offset @ i16] => instructions16::Jg { offset: >::into(offset) }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:576:24 [INFO] [stdout] | [INFO] [stdout] 576 | dest1: modrm.register().into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 576 - dest1: modrm.register().into(), [INFO] [stdout] 576 + dest1: modrm.register(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 576 - dest1: modrm.register().into(), [INFO] [stdout] 576 + dest1: as Into<_>>::into(modrm.register()), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:582:43 [INFO] [stdout] | [INFO] [stdout] 582 | instructions::Lss { dest: modrm.register().into(), src: modrm.memory()?.into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 582 - instructions::Lss { dest: modrm.register().into(), src: modrm.memory()?.into() }.into(), [INFO] [stdout] 582 + instructions::Lss { dest: modrm.register(), src: modrm.memory()?.into() }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 582 - instructions::Lss { dest: modrm.register().into(), src: modrm.memory()?.into() }.into(), [INFO] [stdout] 582 + instructions::Lss { dest: as Into<_>>::into(modrm.register()), src: modrm.memory()?.into() }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:584:43 [INFO] [stdout] | [INFO] [stdout] 584 | instructions::Lfs { dest: modrm.register().into(), src: modrm.memory()?.into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 584 - instructions::Lfs { dest: modrm.register().into(), src: modrm.memory()?.into() }.into(), [INFO] [stdout] 584 + instructions::Lfs { dest: modrm.register(), src: modrm.memory()?.into() }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 584 - instructions::Lfs { dest: modrm.register().into(), src: modrm.memory()?.into() }.into(), [INFO] [stdout] 584 + instructions::Lfs { dest: as Into<_>>::into(modrm.register()), src: modrm.memory()?.into() }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:586:43 [INFO] [stdout] | [INFO] [stdout] 586 | instructions::Lgs { dest: modrm.register().into(), src: modrm.memory()?.into() }.into(), [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 586 - instructions::Lgs { dest: modrm.register().into(), src: modrm.memory()?.into() }.into(), [INFO] [stdout] 586 + instructions::Lgs { dest: modrm.register(), src: modrm.memory()?.into() }.into(), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 586 - instructions::Lgs { dest: modrm.register().into(), src: modrm.memory()?.into() }.into(), [INFO] [stdout] 586 + instructions::Lgs { dest: as Into<_>>::into(modrm.register()), src: modrm.memory()?.into() }.into(), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:757:55 [INFO] [stdout] | [INFO] [stdout] 757 | return Ok(instructions16::Inc { dest: reg.into() }.into()); [INFO] [stdout] | ^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 757 - return Ok(instructions16::Inc { dest: reg.into() }.into()); [INFO] [stdout] 757 + return Ok(instructions16::Inc { dest: reg }.into()); [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 757 - return Ok(instructions16::Inc { dest: reg.into() }.into()); [INFO] [stdout] 757 + return Ok(instructions16::Inc { dest: as Into<_>>::into(reg) }.into()); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:761:55 [INFO] [stdout] | [INFO] [stdout] 761 | return Ok(instructions16::Dec { dest: reg.into() }.into()); [INFO] [stdout] | ^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 761 - return Ok(instructions16::Dec { dest: reg.into() }.into()); [INFO] [stdout] 761 + return Ok(instructions16::Dec { dest: reg }.into()); [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 761 - return Ok(instructions16::Dec { dest: reg.into() }.into()); [INFO] [stdout] 761 + return Ok(instructions16::Dec { dest: as Into<_>>::into(reg) }.into()); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:769:55 [INFO] [stdout] | [INFO] [stdout] 769 | return Ok(instructions16::Pop { dest: reg.into() }.into()); [INFO] [stdout] | ^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 769 - return Ok(instructions16::Pop { dest: reg.into() }.into()); [INFO] [stdout] 769 + return Ok(instructions16::Pop { dest: reg }.into()); [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 769 - return Ok(instructions16::Pop { dest: reg.into() }.into()); [INFO] [stdout] 769 + return Ok(instructions16::Pop { dest: as Into<_>>::into(reg) }.into()); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:778:79 [INFO] [stdout] | [INFO] [stdout] 778 | return Ok(instructions16::Xchg { a: Register16::AX.into(), b: reg.into() }.into()); [INFO] [stdout] | ^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 778 - return Ok(instructions16::Xchg { a: Register16::AX.into(), b: reg.into() }.into()); [INFO] [stdout] 778 + return Ok(instructions16::Xchg { a: Register16::AX.into(), b: reg }.into()); [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 778 - return Ok(instructions16::Xchg { a: Register16::AX.into(), b: reg.into() }.into()); [INFO] [stdout] 778 + return Ok(instructions16::Xchg { a: Register16::AX.into(), b: as Into<_>>::into(reg) }.into()); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:785:54 [INFO] [stdout] | [INFO] [stdout] 785 | return Ok(instructions8::Mov { dest: reg.into(), src: imm.into() }.into()); [INFO] [stdout] | ^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 785 - return Ok(instructions8::Mov { dest: reg.into(), src: imm.into() }.into()); [INFO] [stdout] 785 + return Ok(instructions8::Mov { dest: reg, src: imm.into() }.into()); [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 785 - return Ok(instructions8::Mov { dest: reg.into(), src: imm.into() }.into()); [INFO] [stdout] 785 + return Ok(instructions8::Mov { dest: as Into<_>>::into(reg), src: imm.into() }.into()); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `instruction::MutOperand` [INFO] [stdout] --> src/disasm/decoder.rs:790:55 [INFO] [stdout] | [INFO] [stdout] 790 | return Ok(instructions16::Mov { dest: reg.into(), src: imm.into() }.into()); [INFO] [stdout] | ^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 790 - return Ok(instructions16::Mov { dest: reg.into(), src: imm.into() }.into()); [INFO] [stdout] 790 + return Ok(instructions16::Mov { dest: reg, src: imm.into() }.into()); [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 790 - return Ok(instructions16::Mov { dest: reg.into(), src: imm.into() }.into()); [INFO] [stdout] 790 + return Ok(instructions16::Mov { dest: as Into<_>>::into(reg), src: imm.into() }.into()); [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stderr] error: could not compile `emulator` (bin "emulator") due to 97 previous errors; 4 warnings emitted [INFO] running `Command { std: "docker" "inspect" "2d245efea16870ed17c491527e37418b03b33ecbe698777624859cd29062f668", kill_on_drop: false }` [INFO] running `Command { std: "docker" "rm" "-f" "2d245efea16870ed17c491527e37418b03b33ecbe698777624859cd29062f668", kill_on_drop: false }` [INFO] [stdout] 2d245efea16870ed17c491527e37418b03b33ecbe698777624859cd29062f668