[INFO] cloning repository https://github.com/CaptFudgeCake/chip8 [INFO] running `Command { std: "git" "-c" "credential.helper=" "-c" "credential.helper=/workspace/cargo-home/bin/git-credential-null" "clone" "--bare" "https://github.com/CaptFudgeCake/chip8" "/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2FCaptFudgeCake%2Fchip8", kill_on_drop: false }` [INFO] [stderr] Cloning into bare repository '/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2FCaptFudgeCake%2Fchip8'... [INFO] running `Command { std: "git" "rev-parse" "HEAD", kill_on_drop: false }` [INFO] [stdout] f5d01bf131d40c348d0c8a3c1b008f7e9d0dc6d3 [INFO] checking CaptFudgeCake/chip8 against a5689b034ad287112f709693384a37f1377eb9cc for pr-129249-3 [INFO] running `Command { std: "git" "clone" "/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2FCaptFudgeCake%2Fchip8" "/workspace/builds/worker-5-tc2/source", kill_on_drop: false }` [INFO] [stderr] Cloning into '/workspace/builds/worker-5-tc2/source'... [INFO] [stderr] done. [INFO] started tweaking git repo https://github.com/CaptFudgeCake/chip8 [INFO] finished tweaking git repo https://github.com/CaptFudgeCake/chip8 [INFO] tweaked toml for git repo https://github.com/CaptFudgeCake/chip8 written to /workspace/builds/worker-5-tc2/source/Cargo.toml [INFO] validating manifest of git repo https://github.com/CaptFudgeCake/chip8 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/CaptFudgeCake/chip8 already has a lockfile, it will not be regenerated [INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "fetch" "--manifest-path" "Cargo.toml", kill_on_drop: false }` [INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-5-tc2/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-5-tc2/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/cargo-home:/opt/rustwide/cargo-home:ro,Z" "-v" "/var/lib/crater-agent-workspace/rustup-home:/opt/rustwide/rustup-home:ro,Z" "-m" "1610612736" "--network" "none" "ghcr.io/rust-lang/crates-build-env/linux@sha256:77db811e55d90add9212f6832c23229e3de5f1c1f9905e8cb07319ea15df73ac" "sleep" "infinity", kill_on_drop: false }` [INFO] [stdout] 9438ab75c93a386a6065dff06743c8b7ec9dbd37839e531dfe5d763a08aa1eb9 [INFO] running `Command { std: "docker" "start" "9438ab75c93a386a6065dff06743c8b7ec9dbd37839e531dfe5d763a08aa1eb9", kill_on_drop: false }` [INFO] running `Command { std: "docker" "inspect" "9438ab75c93a386a6065dff06743c8b7ec9dbd37839e531dfe5d763a08aa1eb9", 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" "9438ab75c93a386a6065dff06743c8b7ec9dbd37839e531dfe5d763a08aa1eb9" "/opt/rustwide/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }` [INFO] running `Command { std: "docker" "inspect" "9438ab75c93a386a6065dff06743c8b7ec9dbd37839e531dfe5d763a08aa1eb9", 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" "9438ab75c93a386a6065dff06743c8b7ec9dbd37839e531dfe5d763a08aa1eb9" "/opt/rustwide/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "check" "--frozen" "--all" "--all-targets" "--message-format=json", kill_on_drop: false }` [INFO] [stderr] Compiling libc v0.2.153 [INFO] [stderr] Compiling autocfg v1.1.0 [INFO] [stderr] Checking cfg-if v1.0.0 [INFO] [stderr] Compiling cfg_aliases v0.1.1 [INFO] [stderr] Compiling signal-hook v0.3.17 [INFO] [stderr] Compiling parking_lot_core v0.9.9 [INFO] [stderr] Checking scopeguard v1.2.0 [INFO] [stderr] Checking log v0.4.21 [INFO] [stderr] Checking smallvec v1.13.1 [INFO] [stderr] Checking bitflags v2.4.2 [INFO] [stderr] Compiling nix v0.28.0 [INFO] [stderr] Compiling lock_api v0.4.11 [INFO] [stderr] Checking signal-hook-registry v1.4.1 [INFO] [stderr] Checking mio v0.8.11 [INFO] [stderr] Checking parking_lot v0.12.1 [INFO] [stderr] Checking signal-hook-mio v0.2.3 [INFO] [stderr] Checking crossterm v0.27.0 [INFO] [stderr] Checking ctrlc v3.4.4 [INFO] [stderr] Checking chip8 v0.1.0 (/opt/rustwide/workdir) [INFO] [stdout] warning: unused import: `super::*` [INFO] [stdout] --> src/main.rs:137:9 [INFO] [stdout] | [INFO] [stdout] 137 | use super::*; [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 import: `crate::Chip8` [INFO] [stdout] --> src/commands/add.rs:28:9 [INFO] [stdout] | [INFO] [stdout] 28 | use crate::Chip8; [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 import: `crate::commands::add::Add` [INFO] [stdout] --> src/commands/add.rs:29:9 [INFO] [stdout] | [INFO] [stdout] 29 | use crate::commands::add::Add; [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused import: `crate::commands::command::Command` [INFO] [stdout] --> src/commands/add.rs:30:9 [INFO] [stdout] | [INFO] [stdout] 30 | use crate::commands::command::Command; [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused import: `crate::Chip8` [INFO] [stdout] --> src/commands/add_to_index.rs:22:9 [INFO] [stdout] | [INFO] [stdout] 22 | use crate::Chip8; [INFO] [stdout] | ^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused import: `crate::commands::add_to_index::AddToIndex` [INFO] [stdout] --> src/commands/add_to_index.rs:23:9 [INFO] [stdout] | [INFO] [stdout] 23 | use crate::commands::add_to_index::AddToIndex; [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused import: `crate::commands::command::Command` [INFO] [stdout] --> src/commands/add_to_index.rs:24:9 [INFO] [stdout] | [INFO] [stdout] 24 | use crate::commands::command::Command; [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused import: `crate::Chip8` [INFO] [stdout] --> src/commands/add_value_to_register.rs:23:9 [INFO] [stdout] | [INFO] [stdout] 23 | use crate::Chip8; [INFO] [stdout] | ^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused import: `crate::commands::add_value_to_register::AddValueToRegister` [INFO] [stdout] --> src/commands/add_value_to_register.rs:24:9 [INFO] [stdout] | [INFO] [stdout] 24 | use crate::commands::add_value_to_register::AddValueToRegister; [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused import: `crate::commands::command::Command` [INFO] [stdout] --> src/commands/add_value_to_register.rs:25:9 [INFO] [stdout] | [INFO] [stdout] 25 | use crate::commands::command::Command; [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused import: `crate::Chip8` [INFO] [stdout] --> src/commands/and.rs:26:9 [INFO] [stdout] | [INFO] [stdout] 26 | use crate::Chip8; [INFO] [stdout] | ^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused import: `crate::commands::and::And` [INFO] [stdout] --> src/commands/and.rs:27:9 [INFO] [stdout] | [INFO] [stdout] 27 | use crate::commands::and::And; [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused import: `crate::commands::command::Command` [INFO] [stdout] --> src/commands/and.rs:28:9 [INFO] [stdout] | [INFO] [stdout] 28 | use crate::commands::command::Command; [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused import: `crate::Chip8` [INFO] [stdout] --> src/commands/binary_coded_decimal.rs:26:9 [INFO] [stdout] | [INFO] [stdout] 26 | use crate::Chip8; [INFO] [stdout] | ^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused import: `crate::commands::binary_coded_decimal::BinaryCodedDecimal` [INFO] [stdout] --> src/commands/binary_coded_decimal.rs:27:9 [INFO] [stdout] | [INFO] [stdout] 27 | use crate::commands::binary_coded_decimal::BinaryCodedDecimal; [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused import: `crate::commands::command::Command` [INFO] [stdout] --> src/commands/binary_coded_decimal.rs:28:9 [INFO] [stdout] | [INFO] [stdout] 28 | use crate::commands::command::Command; [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused import: `crate::Chip8` [INFO] [stdout] --> src/commands/call.rs:22:9 [INFO] [stdout] | [INFO] [stdout] 22 | use crate::Chip8; [INFO] [stdout] | ^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused import: `crate::commands::call::Call` [INFO] [stdout] --> src/commands/call.rs:23:9 [INFO] [stdout] | [INFO] [stdout] 23 | use crate::commands::call::Call; [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused import: `crate::commands::command::Command` [INFO] [stdout] --> src/commands/call.rs:24:9 [INFO] [stdout] | [INFO] [stdout] 24 | use crate::commands::command::Command; [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused import: `crate::Chip8` [INFO] [stdout] --> src/commands/clear_screen.rs:24:9 [INFO] [stdout] | [INFO] [stdout] 24 | use crate::Chip8; [INFO] [stdout] | ^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused import: `crate::commands::clear_screen::ClearScreen` [INFO] [stdout] --> src/commands/clear_screen.rs:25:9 [INFO] [stdout] | [INFO] [stdout] 25 | use crate::commands::clear_screen::ClearScreen; [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused import: `crate::commands::command::Command` [INFO] [stdout] --> src/commands/clear_screen.rs:26:9 [INFO] [stdout] | [INFO] [stdout] 26 | use crate::commands::command::Command; [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused import: `crate::Chip8` [INFO] [stdout] --> src/commands/draw.rs:44:9 [INFO] [stdout] | [INFO] [stdout] 44 | use crate::Chip8; [INFO] [stdout] | ^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused import: `crate::commands::command::Command` [INFO] [stdout] --> src/commands/draw.rs:45:9 [INFO] [stdout] | [INFO] [stdout] 45 | use crate::commands::command::Command; [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused import: `crate::commands::draw::Draw` [INFO] [stdout] --> src/commands/draw.rs:46:9 [INFO] [stdout] | [INFO] [stdout] 46 | use crate::commands::draw::Draw; [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused import: `crate::Chip8` [INFO] [stdout] --> src/commands/jump.rs:21:9 [INFO] [stdout] | [INFO] [stdout] 21 | use crate::Chip8; [INFO] [stdout] | ^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused import: `crate::commands::command::Command` [INFO] [stdout] --> src/commands/jump.rs:22:9 [INFO] [stdout] | [INFO] [stdout] 22 | use crate::commands::command::Command; [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused import: `crate::commands::jump::Jump` [INFO] [stdout] --> src/commands/jump.rs:23:9 [INFO] [stdout] | [INFO] [stdout] 23 | use crate::commands::jump::Jump; [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused import: `crate::Chip8` [INFO] [stdout] --> src/commands/load.rs:25:9 [INFO] [stdout] | [INFO] [stdout] 25 | use crate::Chip8; [INFO] [stdout] | ^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused import: `crate::commands::command::Command` [INFO] [stdout] --> src/commands/load.rs:26:9 [INFO] [stdout] | [INFO] [stdout] 26 | use crate::commands::command::Command; [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused import: `crate::commands::load::Load` [INFO] [stdout] --> src/commands/load.rs:27:9 [INFO] [stdout] | [INFO] [stdout] 27 | use crate::commands::load::Load; [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused import: `crate::Chip8` [INFO] [stdout] --> src/commands/or.rs:26:9 [INFO] [stdout] | [INFO] [stdout] 26 | use crate::Chip8; [INFO] [stdout] | ^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused import: `crate::commands::command::Command` [INFO] [stdout] --> src/commands/or.rs:27:9 [INFO] [stdout] | [INFO] [stdout] 27 | use crate::commands::command::Command; [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused import: `crate::commands::or::Or` [INFO] [stdout] --> src/commands/or.rs:28:9 [INFO] [stdout] | [INFO] [stdout] 28 | use crate::commands::or::Or; [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused import: `crate::Chip8` [INFO] [stdout] --> src/commands/read_into_registers.rs:23:9 [INFO] [stdout] | [INFO] [stdout] 23 | use crate::Chip8; [INFO] [stdout] | ^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused import: `crate::commands::command::Command` [INFO] [stdout] --> src/commands/read_into_registers.rs:24:9 [INFO] [stdout] | [INFO] [stdout] 24 | use crate::commands::command::Command; [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused import: `crate::commands::read_into_registers::ReadIntoRegisters` [INFO] [stdout] --> src/commands/read_into_registers.rs:25:9 [INFO] [stdout] | [INFO] [stdout] 25 | use crate::commands::read_into_registers::ReadIntoRegisters; [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused import: `crate::Chip8` [INFO] [stdout] --> src/commands/return_command.rs:22:9 [INFO] [stdout] | [INFO] [stdout] 22 | use crate::Chip8; [INFO] [stdout] | ^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused import: `crate::commands::command::Command` [INFO] [stdout] --> src/commands/return_command.rs:23:9 [INFO] [stdout] | [INFO] [stdout] 23 | use crate::commands::command::Command; [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused import: `crate::commands::return_command::Return` [INFO] [stdout] --> src/commands/return_command.rs:24:9 [INFO] [stdout] | [INFO] [stdout] 24 | use crate::commands::return_command::Return; [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused import: `crate::Chip8` [INFO] [stdout] --> src/commands/set_index_register.rs:21:9 [INFO] [stdout] | [INFO] [stdout] 21 | use crate::Chip8; [INFO] [stdout] | ^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused import: `crate::commands::command::Command` [INFO] [stdout] --> src/commands/set_index_register.rs:22:9 [INFO] [stdout] | [INFO] [stdout] 22 | use crate::commands::command::Command; [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused import: `crate::commands::set_index_register::SetIndexRegister` [INFO] [stdout] --> src/commands/set_index_register.rs:23:9 [INFO] [stdout] | [INFO] [stdout] 23 | use crate::commands::set_index_register::SetIndexRegister; [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused import: `crate::Chip8` [INFO] [stdout] --> src/commands/set_register.rs:22:9 [INFO] [stdout] | [INFO] [stdout] 22 | use crate::Chip8; [INFO] [stdout] | ^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused import: `crate::commands::command::Command` [INFO] [stdout] --> src/commands/set_register.rs:23:9 [INFO] [stdout] | [INFO] [stdout] 23 | use crate::commands::command::Command; [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused import: `crate::commands::set_register::SetRegister` [INFO] [stdout] --> src/commands/set_register.rs:24:9 [INFO] [stdout] | [INFO] [stdout] 24 | use crate::commands::set_register::SetRegister; [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused import: `crate::Chip8` [INFO] [stdout] --> src/commands/shift_left.rs:33:9 [INFO] [stdout] | [INFO] [stdout] 33 | use crate::Chip8; [INFO] [stdout] | ^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused import: `crate::commands::command::Command` [INFO] [stdout] --> src/commands/shift_left.rs:34:9 [INFO] [stdout] | [INFO] [stdout] 34 | use crate::commands::command::Command; [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused import: `crate::commands::shift_left::ShiftLeft` [INFO] [stdout] --> src/commands/shift_left.rs:35:9 [INFO] [stdout] | [INFO] [stdout] 35 | use crate::commands::shift_left::ShiftLeft; [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused import: `crate::Chip8` [INFO] [stdout] --> src/commands/shift_right.rs:33:9 [INFO] [stdout] | [INFO] [stdout] 33 | use crate::Chip8; [INFO] [stdout] | ^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused import: `crate::commands::command::Command` [INFO] [stdout] --> src/commands/shift_right.rs:34:9 [INFO] [stdout] | [INFO] [stdout] 34 | use crate::commands::command::Command; [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused import: `crate::commands::shift_right::ShiftRight` [INFO] [stdout] --> src/commands/shift_right.rs:35:9 [INFO] [stdout] | [INFO] [stdout] 35 | use crate::commands::shift_right::ShiftRight; [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused import: `crate::Chip8` [INFO] [stdout] --> src/commands/skip_equal_x.rs:26:9 [INFO] [stdout] | [INFO] [stdout] 26 | use crate::Chip8; [INFO] [stdout] | ^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused import: `crate::commands::command::Command` [INFO] [stdout] --> src/commands/skip_equal_x.rs:27:9 [INFO] [stdout] | [INFO] [stdout] 27 | use crate::commands::command::Command; [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused import: `crate::commands::skip_equal_x::SkipEqualX` [INFO] [stdout] --> src/commands/skip_equal_x.rs:28:9 [INFO] [stdout] | [INFO] [stdout] 28 | use crate::commands::skip_equal_x::SkipEqualX; [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused import: `crate::Chip8` [INFO] [stdout] --> src/commands/skip_equal_x_y.rs:29:9 [INFO] [stdout] | [INFO] [stdout] 29 | use crate::Chip8; [INFO] [stdout] | ^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused import: `crate::commands::command::Command` [INFO] [stdout] --> src/commands/skip_equal_x_y.rs:30:9 [INFO] [stdout] | [INFO] [stdout] 30 | use crate::commands::command::Command; [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused import: `crate::commands::skip_equal_x_y::SkipEqualXY` [INFO] [stdout] --> src/commands/skip_equal_x_y.rs:31:9 [INFO] [stdout] | [INFO] [stdout] 31 | use crate::commands::skip_equal_x_y::SkipEqualXY; [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused import: `crate::Chip8` [INFO] [stdout] --> src/commands/skip_not_equal_x.rs:27:9 [INFO] [stdout] | [INFO] [stdout] 27 | use crate::Chip8; [INFO] [stdout] | ^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused import: `crate::commands::command::Command` [INFO] [stdout] --> src/commands/skip_not_equal_x.rs:28:9 [INFO] [stdout] | [INFO] [stdout] 28 | use crate::commands::command::Command; [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused import: `crate::commands::skip_not_equal_x::SkipNotEqualX` [INFO] [stdout] --> src/commands/skip_not_equal_x.rs:29:9 [INFO] [stdout] | [INFO] [stdout] 29 | use crate::commands::skip_not_equal_x::SkipNotEqualX; [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused import: `crate::Chip8` [INFO] [stdout] --> src/commands/skip_not_equal_xy.rs:29:9 [INFO] [stdout] | [INFO] [stdout] 29 | use crate::Chip8; [INFO] [stdout] | ^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused import: `crate::commands::command::Command` [INFO] [stdout] --> src/commands/skip_not_equal_xy.rs:30:9 [INFO] [stdout] | [INFO] [stdout] 30 | use crate::commands::command::Command; [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused import: `crate::commands::skip_not_equal_xy::SkipNotEqualXY` [INFO] [stdout] --> src/commands/skip_not_equal_xy.rs:31:9 [INFO] [stdout] | [INFO] [stdout] 31 | use crate::commands::skip_not_equal_xy::SkipNotEqualXY; [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused import: `crate::Chip8` [INFO] [stdout] --> src/commands/store_registers.rs:23:9 [INFO] [stdout] | [INFO] [stdout] 23 | use crate::Chip8; [INFO] [stdout] | ^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused import: `crate::commands::command::Command` [INFO] [stdout] --> src/commands/store_registers.rs:24:9 [INFO] [stdout] | [INFO] [stdout] 24 | use crate::commands::command::Command; [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused import: `crate::commands::store_registers::StoreRegisters` [INFO] [stdout] --> src/commands/store_registers.rs:25:9 [INFO] [stdout] | [INFO] [stdout] 25 | use crate::commands::store_registers::StoreRegisters; [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused import: `crate::Chip8` [INFO] [stdout] --> src/commands/sub.rs:28:9 [INFO] [stdout] | [INFO] [stdout] 28 | use crate::Chip8; [INFO] [stdout] | ^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused import: `crate::commands::command::Command` [INFO] [stdout] --> src/commands/sub.rs:29:9 [INFO] [stdout] | [INFO] [stdout] 29 | use crate::commands::command::Command; [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused import: `crate::commands::sub::Sub` [INFO] [stdout] --> src/commands/sub.rs:30:9 [INFO] [stdout] | [INFO] [stdout] 30 | use crate::commands::sub::Sub; [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused import: `crate::Chip8` [INFO] [stdout] --> src/commands/sub_n.rs:28:9 [INFO] [stdout] | [INFO] [stdout] 28 | use crate::Chip8; [INFO] [stdout] | ^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused import: `crate::commands::command::Command` [INFO] [stdout] --> src/commands/sub_n.rs:29:9 [INFO] [stdout] | [INFO] [stdout] 29 | use crate::commands::command::Command; [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused import: `crate::commands::sub_n::SubN` [INFO] [stdout] --> src/commands/sub_n.rs:30:9 [INFO] [stdout] | [INFO] [stdout] 30 | use crate::commands::sub_n::SubN; [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused import: `crate::Chip8` [INFO] [stdout] --> src/commands/xor.rs:26:9 [INFO] [stdout] | [INFO] [stdout] 26 | use crate::Chip8; [INFO] [stdout] | ^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused import: `crate::commands::command::Command` [INFO] [stdout] --> src/commands/xor.rs:27:9 [INFO] [stdout] | [INFO] [stdout] 27 | use crate::commands::command::Command; [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: unused import: `crate::commands::xor::Xor` [INFO] [stdout] --> src/commands/xor.rs:28:9 [INFO] [stdout] | [INFO] [stdout] 28 | use crate::commands::xor::Xor; [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: field `sound_timer` is never read [INFO] [stdout] --> src/main.rs:25:5 [INFO] [stdout] | [INFO] [stdout] 18 | struct Chip8 { [INFO] [stdout] | ----- field in this struct [INFO] [stdout] ... [INFO] [stdout] 25 | sound_timer: u8, [INFO] [stdout] | ^^^^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: `#[warn(dead_code)]` (part of `#[warn(unused)]`) on by default [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: enum `Chip8Commands` is never used [INFO] [stdout] --> src/chip8_commands.rs:2:17 [INFO] [stdout] | [INFO] [stdout] 2 | pub(crate) enum Chip8Commands { [INFO] [stdout] | ^^^^^^^^^^^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: associated function `new` is never used [INFO] [stdout] --> src/chip8_commands.rs:31:12 [INFO] [stdout] | [INFO] [stdout] 30 | impl Chip8Commands { [INFO] [stdout] | ------------------ associated function in this implementation [INFO] [stdout] 31 | pub fn new(command: &[u8]) -> Chip8Commands { [INFO] [stdout] | ^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: associated function `new` is never used [INFO] [stdout] --> src/commands/clear_screen.rs:7:12 [INFO] [stdout] | [INFO] [stdout] 6 | impl ClearScreen { [INFO] [stdout] | ---------------- associated function in this implementation [INFO] [stdout] 7 | pub fn new() -> Self { [INFO] [stdout] | ^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: associated function `new` is never used [INFO] [stdout] --> src/commands/return_command.rs:7:12 [INFO] [stdout] | [INFO] [stdout] 6 | impl Return { [INFO] [stdout] | ----------- associated function in this implementation [INFO] [stdout] 7 | pub fn new() -> Self { [INFO] [stdout] | ^^^ [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/chip8_commands.rs:42:52 [INFO] [stdout] | [INFO] [stdout] 42 | 3 => Chip8Commands::SkipEqualX(x.into(), command[1]), [INFO] [stdout] | ^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: `#[deny(self_type_conversion)]` on by default [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 42 - 3 => Chip8Commands::SkipEqualX(x.into(), command[1]), [INFO] [stdout] 42 + 3 => Chip8Commands::SkipEqualX(x, command[1]), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 42 - 3 => Chip8Commands::SkipEqualX(x.into(), command[1]), [INFO] [stdout] 42 + 3 => Chip8Commands::SkipEqualX(>::into(x), command[1]), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/chip8_commands.rs:43:55 [INFO] [stdout] | [INFO] [stdout] 43 | 4 => Chip8Commands::SkipNotEqualX(x.into(), command[1]), [INFO] [stdout] | ^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 43 - 4 => Chip8Commands::SkipNotEqualX(x.into(), command[1]), [INFO] [stdout] 43 + 4 => Chip8Commands::SkipNotEqualX(x, command[1]), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 43 - 4 => Chip8Commands::SkipNotEqualX(x.into(), command[1]), [INFO] [stdout] 43 + 4 => Chip8Commands::SkipNotEqualX(>::into(x), command[1]), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/chip8_commands.rs:44:53 [INFO] [stdout] | [INFO] [stdout] 44 | 6 => Chip8Commands::SetRegister(x.into(), command[1]), [INFO] [stdout] | ^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 44 - 6 => Chip8Commands::SetRegister(x.into(), command[1]), [INFO] [stdout] 44 + 6 => Chip8Commands::SetRegister(x, command[1]), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 44 - 6 => Chip8Commands::SetRegister(x.into(), command[1]), [INFO] [stdout] 44 + 6 => Chip8Commands::SetRegister(>::into(x), command[1]), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/chip8_commands.rs:45:60 [INFO] [stdout] | [INFO] [stdout] 45 | 7 => Chip8Commands::AddValueToRegister(x.into(), command[1]), [INFO] [stdout] | ^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 45 - 7 => Chip8Commands::AddValueToRegister(x.into(), command[1]), [INFO] [stdout] 45 + 7 => Chip8Commands::AddValueToRegister(x, command[1]), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 45 - 7 => Chip8Commands::AddValueToRegister(x.into(), command[1]), [INFO] [stdout] 45 + 7 => Chip8Commands::AddValueToRegister(>::into(x), command[1]), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/chip8_commands.rs:54:48 [INFO] [stdout] | [INFO] [stdout] 54 | 0x0 => Chip8Commands::Load(x.into(), y.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] 54 - 0x0 => Chip8Commands::Load(x.into(), y.into()), [INFO] [stdout] 54 + 0x0 => Chip8Commands::Load(x, y.into()), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 54 - 0x0 => Chip8Commands::Load(x.into(), y.into()), [INFO] [stdout] 54 + 0x0 => Chip8Commands::Load(>::into(x), y.into()), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/chip8_commands.rs:54:58 [INFO] [stdout] | [INFO] [stdout] 54 | 0x0 => Chip8Commands::Load(x.into(), y.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] 54 - 0x0 => Chip8Commands::Load(x.into(), y.into()), [INFO] [stdout] 54 + 0x0 => Chip8Commands::Load(x.into(), y), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 54 - 0x0 => Chip8Commands::Load(x.into(), y.into()), [INFO] [stdout] 54 + 0x0 => Chip8Commands::Load(x.into(), >::into(y)), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/chip8_commands.rs:55:46 [INFO] [stdout] | [INFO] [stdout] 55 | 0x1 => Chip8Commands::OR(x.into(), y.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] 55 - 0x1 => Chip8Commands::OR(x.into(), y.into()), [INFO] [stdout] 55 + 0x1 => Chip8Commands::OR(x, y.into()), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 55 - 0x1 => Chip8Commands::OR(x.into(), y.into()), [INFO] [stdout] 55 + 0x1 => Chip8Commands::OR(>::into(x), y.into()), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/chip8_commands.rs:55:56 [INFO] [stdout] | [INFO] [stdout] 55 | 0x1 => Chip8Commands::OR(x.into(), y.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] 55 - 0x1 => Chip8Commands::OR(x.into(), y.into()), [INFO] [stdout] 55 + 0x1 => Chip8Commands::OR(x.into(), y), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 55 - 0x1 => Chip8Commands::OR(x.into(), y.into()), [INFO] [stdout] 55 + 0x1 => Chip8Commands::OR(x.into(), >::into(y)), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/chip8_commands.rs:56:47 [INFO] [stdout] | [INFO] [stdout] 56 | 0x2 => Chip8Commands::AND(x.into(), y.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] 56 - 0x2 => Chip8Commands::AND(x.into(), y.into()), [INFO] [stdout] 56 + 0x2 => Chip8Commands::AND(x, y.into()), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 56 - 0x2 => Chip8Commands::AND(x.into(), y.into()), [INFO] [stdout] 56 + 0x2 => Chip8Commands::AND(>::into(x), y.into()), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/chip8_commands.rs:56:57 [INFO] [stdout] | [INFO] [stdout] 56 | 0x2 => Chip8Commands::AND(x.into(), y.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] 56 - 0x2 => Chip8Commands::AND(x.into(), y.into()), [INFO] [stdout] 56 + 0x2 => Chip8Commands::AND(x.into(), y), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 56 - 0x2 => Chip8Commands::AND(x.into(), y.into()), [INFO] [stdout] 56 + 0x2 => Chip8Commands::AND(x.into(), >::into(y)), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/chip8_commands.rs:57:47 [INFO] [stdout] | [INFO] [stdout] 57 | 0x3 => Chip8Commands::XOR(x.into(), y.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] 57 - 0x3 => Chip8Commands::XOR(x.into(), y.into()), [INFO] [stdout] 57 + 0x3 => Chip8Commands::XOR(x, y.into()), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 57 - 0x3 => Chip8Commands::XOR(x.into(), y.into()), [INFO] [stdout] 57 + 0x3 => Chip8Commands::XOR(>::into(x), y.into()), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/chip8_commands.rs:57:57 [INFO] [stdout] | [INFO] [stdout] 57 | 0x3 => Chip8Commands::XOR(x.into(), y.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] 57 - 0x3 => Chip8Commands::XOR(x.into(), y.into()), [INFO] [stdout] 57 + 0x3 => Chip8Commands::XOR(x.into(), y), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 57 - 0x3 => Chip8Commands::XOR(x.into(), y.into()), [INFO] [stdout] 57 + 0x3 => Chip8Commands::XOR(x.into(), >::into(y)), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/chip8_commands.rs:58:47 [INFO] [stdout] | [INFO] [stdout] 58 | 0x4 => Chip8Commands::ADD(x.into(), y.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] 58 - 0x4 => Chip8Commands::ADD(x.into(), y.into()), [INFO] [stdout] 58 + 0x4 => Chip8Commands::ADD(x, y.into()), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 58 - 0x4 => Chip8Commands::ADD(x.into(), y.into()), [INFO] [stdout] 58 + 0x4 => Chip8Commands::ADD(>::into(x), y.into()), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/chip8_commands.rs:58:57 [INFO] [stdout] | [INFO] [stdout] 58 | 0x4 => Chip8Commands::ADD(x.into(), y.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] 58 - 0x4 => Chip8Commands::ADD(x.into(), y.into()), [INFO] [stdout] 58 + 0x4 => Chip8Commands::ADD(x.into(), y), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 58 - 0x4 => Chip8Commands::ADD(x.into(), y.into()), [INFO] [stdout] 58 + 0x4 => Chip8Commands::ADD(x.into(), >::into(y)), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/chip8_commands.rs:59:47 [INFO] [stdout] | [INFO] [stdout] 59 | 0x5 => Chip8Commands::SUB(x.into(), y.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] 59 - 0x5 => Chip8Commands::SUB(x.into(), y.into()), [INFO] [stdout] 59 + 0x5 => Chip8Commands::SUB(x, y.into()), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 59 - 0x5 => Chip8Commands::SUB(x.into(), y.into()), [INFO] [stdout] 59 + 0x5 => Chip8Commands::SUB(>::into(x), y.into()), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/chip8_commands.rs:59:57 [INFO] [stdout] | [INFO] [stdout] 59 | 0x5 => Chip8Commands::SUB(x.into(), y.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] 59 - 0x5 => Chip8Commands::SUB(x.into(), y.into()), [INFO] [stdout] 59 + 0x5 => Chip8Commands::SUB(x.into(), y), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 59 - 0x5 => Chip8Commands::SUB(x.into(), y.into()), [INFO] [stdout] 59 + 0x5 => Chip8Commands::SUB(x.into(), >::into(y)), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/chip8_commands.rs:60:54 [INFO] [stdout] | [INFO] [stdout] 60 | 0x6 => Chip8Commands::ShiftRight(x.into(), y.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] 60 - 0x6 => Chip8Commands::ShiftRight(x.into(), y.into()), [INFO] [stdout] 60 + 0x6 => Chip8Commands::ShiftRight(x, y.into()), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 60 - 0x6 => Chip8Commands::ShiftRight(x.into(), y.into()), [INFO] [stdout] 60 + 0x6 => Chip8Commands::ShiftRight(>::into(x), y.into()), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/chip8_commands.rs:60:64 [INFO] [stdout] | [INFO] [stdout] 60 | 0x6 => Chip8Commands::ShiftRight(x.into(), y.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] 60 - 0x6 => Chip8Commands::ShiftRight(x.into(), y.into()), [INFO] [stdout] 60 + 0x6 => Chip8Commands::ShiftRight(x.into(), y), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 60 - 0x6 => Chip8Commands::ShiftRight(x.into(), y.into()), [INFO] [stdout] 60 + 0x6 => Chip8Commands::ShiftRight(x.into(), >::into(y)), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/chip8_commands.rs:61:48 [INFO] [stdout] | [INFO] [stdout] 61 | 0x7 => Chip8Commands::SUBN(x.into(), y.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] 61 - 0x7 => Chip8Commands::SUBN(x.into(), y.into()), [INFO] [stdout] 61 + 0x7 => Chip8Commands::SUBN(x, y.into()), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 61 - 0x7 => Chip8Commands::SUBN(x.into(), y.into()), [INFO] [stdout] 61 + 0x7 => Chip8Commands::SUBN(>::into(x), y.into()), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/chip8_commands.rs:61:58 [INFO] [stdout] | [INFO] [stdout] 61 | 0x7 => Chip8Commands::SUBN(x.into(), y.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] 61 - 0x7 => Chip8Commands::SUBN(x.into(), y.into()), [INFO] [stdout] 61 + 0x7 => Chip8Commands::SUBN(x.into(), y), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 61 - 0x7 => Chip8Commands::SUBN(x.into(), y.into()), [INFO] [stdout] 61 + 0x7 => Chip8Commands::SUBN(x.into(), >::into(y)), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/chip8_commands.rs:62:53 [INFO] [stdout] | [INFO] [stdout] 62 | 0xE => Chip8Commands::ShiftLeft(x.into(), y.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] 62 - 0xE => Chip8Commands::ShiftLeft(x.into(), y.into()), [INFO] [stdout] 62 + 0xE => Chip8Commands::ShiftLeft(x, y.into()), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 62 - 0xE => Chip8Commands::ShiftLeft(x.into(), y.into()), [INFO] [stdout] 62 + 0xE => Chip8Commands::ShiftLeft(>::into(x), y.into()), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/chip8_commands.rs:62:63 [INFO] [stdout] | [INFO] [stdout] 62 | 0xE => Chip8Commands::ShiftLeft(x.into(), y.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] 62 - 0xE => Chip8Commands::ShiftLeft(x.into(), y.into()), [INFO] [stdout] 62 + 0xE => Chip8Commands::ShiftLeft(x.into(), y), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 62 - 0xE => Chip8Commands::ShiftLeft(x.into(), y.into()), [INFO] [stdout] 62 + 0xE => Chip8Commands::ShiftLeft(x.into(), >::into(y)), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/chip8_commands.rs:69:55 [INFO] [stdout] | [INFO] [stdout] 69 | 0x1E => Chip8Commands::AddToIndex(x.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] 69 - 0x1E => Chip8Commands::AddToIndex(x.into()), [INFO] [stdout] 69 + 0x1E => Chip8Commands::AddToIndex(x), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 69 - 0x1E => Chip8Commands::AddToIndex(x.into()), [INFO] [stdout] 69 + 0x1E => Chip8Commands::AddToIndex(>::into(x)), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/chip8_commands.rs:70:63 [INFO] [stdout] | [INFO] [stdout] 70 | 0x33 => Chip8Commands::BinaryCodedDecimal(x.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] 70 - 0x33 => Chip8Commands::BinaryCodedDecimal(x.into()), [INFO] [stdout] 70 + 0x33 => Chip8Commands::BinaryCodedDecimal(x), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 70 - 0x33 => Chip8Commands::BinaryCodedDecimal(x.into()), [INFO] [stdout] 70 + 0x33 => Chip8Commands::BinaryCodedDecimal(>::into(x)), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/chip8_commands.rs:71:59 [INFO] [stdout] | [INFO] [stdout] 71 | 0x55 => Chip8Commands::StoreRegisters(x.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] 71 - 0x55 => Chip8Commands::StoreRegisters(x.into()), [INFO] [stdout] 71 + 0x55 => Chip8Commands::StoreRegisters(x), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 71 - 0x55 => Chip8Commands::StoreRegisters(x.into()), [INFO] [stdout] 71 + 0x55 => Chip8Commands::StoreRegisters(>::into(x)), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/chip8_commands.rs:72:62 [INFO] [stdout] | [INFO] [stdout] 72 | 0x65 => Chip8Commands::ReadIntoRegisters(x.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] 72 - 0x65 => Chip8Commands::ReadIntoRegisters(x.into()), [INFO] [stdout] 72 + 0x65 => Chip8Commands::ReadIntoRegisters(x), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 72 - 0x65 => Chip8Commands::ReadIntoRegisters(x.into()), [INFO] [stdout] 72 + 0x65 => Chip8Commands::ReadIntoRegisters(>::into(x)), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/chip8_commands.rs:88:44 [INFO] [stdout] | [INFO] [stdout] 88 | Chip8Commands::SkipEqualXY(x.into(), y.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] 88 - Chip8Commands::SkipEqualXY(x.into(), y.into()) [INFO] [stdout] 88 + Chip8Commands::SkipEqualXY(x, y.into()) [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 88 - Chip8Commands::SkipEqualXY(x.into(), y.into()) [INFO] [stdout] 88 + Chip8Commands::SkipEqualXY(>::into(x), y.into()) [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/chip8_commands.rs:88:54 [INFO] [stdout] | [INFO] [stdout] 88 | Chip8Commands::SkipEqualXY(x.into(), y.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] 88 - Chip8Commands::SkipEqualXY(x.into(), y.into()) [INFO] [stdout] 88 + Chip8Commands::SkipEqualXY(x.into(), y) [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 88 - Chip8Commands::SkipEqualXY(x.into(), y.into()) [INFO] [stdout] 88 + Chip8Commands::SkipEqualXY(x.into(), >::into(y)) [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/chip8_commands.rs:93:47 [INFO] [stdout] | [INFO] [stdout] 93 | Chip8Commands::SkipNotEqualXY(x.into(), y.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] 93 - Chip8Commands::SkipNotEqualXY(x.into(), y.into()) [INFO] [stdout] 93 + Chip8Commands::SkipNotEqualXY(x, y.into()) [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 93 - Chip8Commands::SkipNotEqualXY(x.into(), y.into()) [INFO] [stdout] 93 + Chip8Commands::SkipNotEqualXY(>::into(x), y.into()) [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/chip8_commands.rs:93:57 [INFO] [stdout] | [INFO] [stdout] 93 | Chip8Commands::SkipNotEqualXY(x.into(), y.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] 93 - Chip8Commands::SkipNotEqualXY(x.into(), y.into()) [INFO] [stdout] 93 + Chip8Commands::SkipNotEqualXY(x.into(), y) [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 93 - Chip8Commands::SkipNotEqualXY(x.into(), y.into()) [INFO] [stdout] 93 + Chip8Commands::SkipNotEqualXY(x.into(), >::into(y)) [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/chip8_commands.rs:99:37 [INFO] [stdout] | [INFO] [stdout] 99 | Chip8Commands::Draw(x.into(), y.into(), bytes) [INFO] [stdout] | ^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 99 - Chip8Commands::Draw(x.into(), y.into(), bytes) [INFO] [stdout] 99 + Chip8Commands::Draw(x, y.into(), bytes) [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 99 - Chip8Commands::Draw(x.into(), y.into(), bytes) [INFO] [stdout] 99 + Chip8Commands::Draw(>::into(x), y.into(), bytes) [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/chip8_commands.rs:99:47 [INFO] [stdout] | [INFO] [stdout] 99 | Chip8Commands::Draw(x.into(), y.into(), bytes) [INFO] [stdout] | ^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 99 - Chip8Commands::Draw(x.into(), y.into(), bytes) [INFO] [stdout] 99 + Chip8Commands::Draw(x.into(), y, bytes) [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 99 - Chip8Commands::Draw(x.into(), y.into(), bytes) [INFO] [stdout] 99 + Chip8Commands::Draw(x.into(), >::into(y), bytes) [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/commands/command_parser.rs:42:50 [INFO] [stdout] | [INFO] [stdout] 42 | 4 => Box::new(SkipNotEqualX::new(x.into(), command[1])), [INFO] [stdout] | ^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 42 - 4 => Box::new(SkipNotEqualX::new(x.into(), command[1])), [INFO] [stdout] 42 + 4 => Box::new(SkipNotEqualX::new(x, command[1])), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 42 - 4 => Box::new(SkipNotEqualX::new(x.into(), command[1])), [INFO] [stdout] 42 + 4 => Box::new(SkipNotEqualX::new(>::into(x), command[1])), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/commands/command_parser.rs:43:48 [INFO] [stdout] | [INFO] [stdout] 43 | 6 => Box::new(SetRegister::new(x.into(), command[1])), [INFO] [stdout] | ^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 43 - 6 => Box::new(SetRegister::new(x.into(), command[1])), [INFO] [stdout] 43 + 6 => Box::new(SetRegister::new(x, command[1])), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 43 - 6 => Box::new(SetRegister::new(x.into(), command[1])), [INFO] [stdout] 43 + 6 => Box::new(SetRegister::new(>::into(x), command[1])), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/commands/command_parser.rs:44:55 [INFO] [stdout] | [INFO] [stdout] 44 | 7 => Box::new(AddValueToRegister::new(x.into(), command[1])), [INFO] [stdout] | ^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 44 - 7 => Box::new(AddValueToRegister::new(x.into(), command[1])), [INFO] [stdout] 44 + 7 => Box::new(AddValueToRegister::new(x, command[1])), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 44 - 7 => Box::new(AddValueToRegister::new(x.into(), command[1])), [INFO] [stdout] 44 + 7 => Box::new(AddValueToRegister::new(>::into(x), command[1])), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/commands/command_parser.rs:53:43 [INFO] [stdout] | [INFO] [stdout] 53 | 0x0 => Box::new(Load::new(x.into(), y.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] 53 - 0x0 => Box::new(Load::new(x.into(), y.into())), [INFO] [stdout] 53 + 0x0 => Box::new(Load::new(x, y.into())), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 53 - 0x0 => Box::new(Load::new(x.into(), y.into())), [INFO] [stdout] 53 + 0x0 => Box::new(Load::new(>::into(x), y.into())), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/commands/command_parser.rs:53:53 [INFO] [stdout] | [INFO] [stdout] 53 | 0x0 => Box::new(Load::new(x.into(), y.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] 53 - 0x0 => Box::new(Load::new(x.into(), y.into())), [INFO] [stdout] 53 + 0x0 => Box::new(Load::new(x.into(), y)), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 53 - 0x0 => Box::new(Load::new(x.into(), y.into())), [INFO] [stdout] 53 + 0x0 => Box::new(Load::new(x.into(), >::into(y))), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/commands/command_parser.rs:54:41 [INFO] [stdout] | [INFO] [stdout] 54 | 0x1 => Box::new(Or::new(x.into(), y.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] 54 - 0x1 => Box::new(Or::new(x.into(), y.into())), [INFO] [stdout] 54 + 0x1 => Box::new(Or::new(x, y.into())), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 54 - 0x1 => Box::new(Or::new(x.into(), y.into())), [INFO] [stdout] 54 + 0x1 => Box::new(Or::new(>::into(x), y.into())), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/commands/command_parser.rs:54:51 [INFO] [stdout] | [INFO] [stdout] 54 | 0x1 => Box::new(Or::new(x.into(), y.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] 54 - 0x1 => Box::new(Or::new(x.into(), y.into())), [INFO] [stdout] 54 + 0x1 => Box::new(Or::new(x.into(), y)), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 54 - 0x1 => Box::new(Or::new(x.into(), y.into())), [INFO] [stdout] 54 + 0x1 => Box::new(Or::new(x.into(), >::into(y))), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/commands/command_parser.rs:55:42 [INFO] [stdout] | [INFO] [stdout] 55 | 0x2 => Box::new(And::new(x.into(), y.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] 55 - 0x2 => Box::new(And::new(x.into(), y.into())), [INFO] [stdout] 55 + 0x2 => Box::new(And::new(x, y.into())), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 55 - 0x2 => Box::new(And::new(x.into(), y.into())), [INFO] [stdout] 55 + 0x2 => Box::new(And::new(>::into(x), y.into())), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/commands/command_parser.rs:55:52 [INFO] [stdout] | [INFO] [stdout] 55 | 0x2 => Box::new(And::new(x.into(), y.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] 55 - 0x2 => Box::new(And::new(x.into(), y.into())), [INFO] [stdout] 55 + 0x2 => Box::new(And::new(x.into(), y)), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 55 - 0x2 => Box::new(And::new(x.into(), y.into())), [INFO] [stdout] 55 + 0x2 => Box::new(And::new(x.into(), >::into(y))), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/commands/command_parser.rs:56:42 [INFO] [stdout] | [INFO] [stdout] 56 | 0x3 => Box::new(Xor::new(x.into(), y.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] 56 - 0x3 => Box::new(Xor::new(x.into(), y.into())), [INFO] [stdout] 56 + 0x3 => Box::new(Xor::new(x, y.into())), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 56 - 0x3 => Box::new(Xor::new(x.into(), y.into())), [INFO] [stdout] 56 + 0x3 => Box::new(Xor::new(>::into(x), y.into())), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/commands/command_parser.rs:56:52 [INFO] [stdout] | [INFO] [stdout] 56 | 0x3 => Box::new(Xor::new(x.into(), y.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] 56 - 0x3 => Box::new(Xor::new(x.into(), y.into())), [INFO] [stdout] 56 + 0x3 => Box::new(Xor::new(x.into(), y)), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 56 - 0x3 => Box::new(Xor::new(x.into(), y.into())), [INFO] [stdout] 56 + 0x3 => Box::new(Xor::new(x.into(), >::into(y))), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/commands/command_parser.rs:57:42 [INFO] [stdout] | [INFO] [stdout] 57 | 0x4 => Box::new(Add::new(x.into(), y.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] 57 - 0x4 => Box::new(Add::new(x.into(), y.into())), [INFO] [stdout] 57 + 0x4 => Box::new(Add::new(x, y.into())), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 57 - 0x4 => Box::new(Add::new(x.into(), y.into())), [INFO] [stdout] 57 + 0x4 => Box::new(Add::new(>::into(x), y.into())), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/commands/command_parser.rs:57:52 [INFO] [stdout] | [INFO] [stdout] 57 | 0x4 => Box::new(Add::new(x.into(), y.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] 57 - 0x4 => Box::new(Add::new(x.into(), y.into())), [INFO] [stdout] 57 + 0x4 => Box::new(Add::new(x.into(), y)), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 57 - 0x4 => Box::new(Add::new(x.into(), y.into())), [INFO] [stdout] 57 + 0x4 => Box::new(Add::new(x.into(), >::into(y))), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/commands/command_parser.rs:58:42 [INFO] [stdout] | [INFO] [stdout] 58 | 0x5 => Box::new(Sub::new(x.into(), y.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] 58 - 0x5 => Box::new(Sub::new(x.into(), y.into())), [INFO] [stdout] 58 + 0x5 => Box::new(Sub::new(x, y.into())), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 58 - 0x5 => Box::new(Sub::new(x.into(), y.into())), [INFO] [stdout] 58 + 0x5 => Box::new(Sub::new(>::into(x), y.into())), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/commands/command_parser.rs:58:52 [INFO] [stdout] | [INFO] [stdout] 58 | 0x5 => Box::new(Sub::new(x.into(), y.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] 58 - 0x5 => Box::new(Sub::new(x.into(), y.into())), [INFO] [stdout] 58 + 0x5 => Box::new(Sub::new(x.into(), y)), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 58 - 0x5 => Box::new(Sub::new(x.into(), y.into())), [INFO] [stdout] 58 + 0x5 => Box::new(Sub::new(x.into(), >::into(y))), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/commands/command_parser.rs:59:49 [INFO] [stdout] | [INFO] [stdout] 59 | 0x6 => Box::new(ShiftRight::new(x.into(), y.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] 59 - 0x6 => Box::new(ShiftRight::new(x.into(), y.into())), [INFO] [stdout] 59 + 0x6 => Box::new(ShiftRight::new(x, y.into())), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 59 - 0x6 => Box::new(ShiftRight::new(x.into(), y.into())), [INFO] [stdout] 59 + 0x6 => Box::new(ShiftRight::new(>::into(x), y.into())), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/commands/command_parser.rs:59:59 [INFO] [stdout] | [INFO] [stdout] 59 | 0x6 => Box::new(ShiftRight::new(x.into(), y.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] 59 - 0x6 => Box::new(ShiftRight::new(x.into(), y.into())), [INFO] [stdout] 59 + 0x6 => Box::new(ShiftRight::new(x.into(), y)), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 59 - 0x6 => Box::new(ShiftRight::new(x.into(), y.into())), [INFO] [stdout] 59 + 0x6 => Box::new(ShiftRight::new(x.into(), >::into(y))), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/commands/command_parser.rs:60:43 [INFO] [stdout] | [INFO] [stdout] 60 | 0x7 => Box::new(SubN::new(x.into(), y.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] 60 - 0x7 => Box::new(SubN::new(x.into(), y.into())), [INFO] [stdout] 60 + 0x7 => Box::new(SubN::new(x, y.into())), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 60 - 0x7 => Box::new(SubN::new(x.into(), y.into())), [INFO] [stdout] 60 + 0x7 => Box::new(SubN::new(>::into(x), y.into())), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/commands/command_parser.rs:60:53 [INFO] [stdout] | [INFO] [stdout] 60 | 0x7 => Box::new(SubN::new(x.into(), y.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] 60 - 0x7 => Box::new(SubN::new(x.into(), y.into())), [INFO] [stdout] 60 + 0x7 => Box::new(SubN::new(x.into(), y)), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 60 - 0x7 => Box::new(SubN::new(x.into(), y.into())), [INFO] [stdout] 60 + 0x7 => Box::new(SubN::new(x.into(), >::into(y))), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/commands/command_parser.rs:61:48 [INFO] [stdout] | [INFO] [stdout] 61 | 0xE => Box::new(ShiftLeft::new(x.into(), y.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] 61 - 0xE => Box::new(ShiftLeft::new(x.into(), y.into())), [INFO] [stdout] 61 + 0xE => Box::new(ShiftLeft::new(x, y.into())), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 61 - 0xE => Box::new(ShiftLeft::new(x.into(), y.into())), [INFO] [stdout] 61 + 0xE => Box::new(ShiftLeft::new(>::into(x), y.into())), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/commands/command_parser.rs:61:58 [INFO] [stdout] | [INFO] [stdout] 61 | 0xE => Box::new(ShiftLeft::new(x.into(), y.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] 61 - 0xE => Box::new(ShiftLeft::new(x.into(), y.into())), [INFO] [stdout] 61 + 0xE => Box::new(ShiftLeft::new(x.into(), y)), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 61 - 0xE => Box::new(ShiftLeft::new(x.into(), y.into())), [INFO] [stdout] 61 + 0xE => Box::new(ShiftLeft::new(x.into(), >::into(y))), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/commands/command_parser.rs:68:60 [INFO] [stdout] | [INFO] [stdout] 68 | 0x07 => Box::new(SetRegisterFromDelay::new(x.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] 68 - 0x07 => Box::new(SetRegisterFromDelay::new(x.into())), [INFO] [stdout] 68 + 0x07 => Box::new(SetRegisterFromDelay::new(x)), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 68 - 0x07 => Box::new(SetRegisterFromDelay::new(x.into())), [INFO] [stdout] 68 + 0x07 => Box::new(SetRegisterFromDelay::new(>::into(x))), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/commands/command_parser.rs:69:53 [INFO] [stdout] | [INFO] [stdout] 69 | 0x15 => Box::new(SetDelayTimer::new(x.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] 69 - 0x15 => Box::new(SetDelayTimer::new(x.into())), [INFO] [stdout] 69 + 0x15 => Box::new(SetDelayTimer::new(x)), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 69 - 0x15 => Box::new(SetDelayTimer::new(x.into())), [INFO] [stdout] 69 + 0x15 => Box::new(SetDelayTimer::new(>::into(x))), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/commands/command_parser.rs:70:50 [INFO] [stdout] | [INFO] [stdout] 70 | 0x1E => Box::new(AddToIndex::new(x.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] 70 - 0x1E => Box::new(AddToIndex::new(x.into())), [INFO] [stdout] 70 + 0x1E => Box::new(AddToIndex::new(x)), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 70 - 0x1E => Box::new(AddToIndex::new(x.into())), [INFO] [stdout] 70 + 0x1E => Box::new(AddToIndex::new(>::into(x))), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/commands/command_parser.rs:71:58 [INFO] [stdout] | [INFO] [stdout] 71 | 0x33 => Box::new(BinaryCodedDecimal::new(x.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] 71 - 0x33 => Box::new(BinaryCodedDecimal::new(x.into())), [INFO] [stdout] 71 + 0x33 => Box::new(BinaryCodedDecimal::new(x)), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 71 - 0x33 => Box::new(BinaryCodedDecimal::new(x.into())), [INFO] [stdout] 71 + 0x33 => Box::new(BinaryCodedDecimal::new(>::into(x))), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/commands/command_parser.rs:72:54 [INFO] [stdout] | [INFO] [stdout] 72 | 0x55 => Box::new(StoreRegisters::new(x.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] 72 - 0x55 => Box::new(StoreRegisters::new(x.into())), [INFO] [stdout] 72 + 0x55 => Box::new(StoreRegisters::new(x)), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 72 - 0x55 => Box::new(StoreRegisters::new(x.into())), [INFO] [stdout] 72 + 0x55 => Box::new(StoreRegisters::new(>::into(x))), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/commands/command_parser.rs:73:57 [INFO] [stdout] | [INFO] [stdout] 73 | 0x65 => Box::new(ReadIntoRegisters::new(x.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] 73 - 0x65 => Box::new(ReadIntoRegisters::new(x.into())), [INFO] [stdout] 73 + 0x65 => Box::new(ReadIntoRegisters::new(x)), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 73 - 0x65 => Box::new(ReadIntoRegisters::new(x.into())), [INFO] [stdout] 73 + 0x65 => Box::new(ReadIntoRegisters::new(>::into(x))), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/commands/command_parser.rs:89:39 [INFO] [stdout] | [INFO] [stdout] 89 | Box::new(SkipEqualXY::new(x.into(), y.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] 89 - Box::new(SkipEqualXY::new(x.into(), y.into())) [INFO] [stdout] 89 + Box::new(SkipEqualXY::new(x, y.into())) [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 89 - Box::new(SkipEqualXY::new(x.into(), y.into())) [INFO] [stdout] 89 + Box::new(SkipEqualXY::new(>::into(x), y.into())) [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/commands/command_parser.rs:89:49 [INFO] [stdout] | [INFO] [stdout] 89 | Box::new(SkipEqualXY::new(x.into(), y.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] 89 - Box::new(SkipEqualXY::new(x.into(), y.into())) [INFO] [stdout] 89 + Box::new(SkipEqualXY::new(x.into(), y)) [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 89 - Box::new(SkipEqualXY::new(x.into(), y.into())) [INFO] [stdout] 89 + Box::new(SkipEqualXY::new(x.into(), >::into(y))) [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/commands/command_parser.rs:94:42 [INFO] [stdout] | [INFO] [stdout] 94 | Box::new(SkipNotEqualXY::new(x.into(), y.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] 94 - Box::new(SkipNotEqualXY::new(x.into(), y.into())) [INFO] [stdout] 94 + Box::new(SkipNotEqualXY::new(x, y.into())) [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 94 - Box::new(SkipNotEqualXY::new(x.into(), y.into())) [INFO] [stdout] 94 + Box::new(SkipNotEqualXY::new(>::into(x), y.into())) [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/commands/command_parser.rs:94:52 [INFO] [stdout] | [INFO] [stdout] 94 | Box::new(SkipNotEqualXY::new(x.into(), y.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] 94 - Box::new(SkipNotEqualXY::new(x.into(), y.into())) [INFO] [stdout] 94 + Box::new(SkipNotEqualXY::new(x.into(), y)) [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 94 - Box::new(SkipNotEqualXY::new(x.into(), y.into())) [INFO] [stdout] 94 + Box::new(SkipNotEqualXY::new(x.into(), >::into(y))) [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stderr] error: could not compile `chip8` (bin "chip8") due to 65 previous errors; 80 warnings emitted [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/commands/command_parser.rs:100:32 [INFO] [stdout] | [INFO] [stdout] 100 | Box::new(Draw::new(x.into(), y.into(), bytes)) [INFO] [stdout] | ^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 100 - Box::new(Draw::new(x.into(), y.into(), bytes)) [INFO] [stdout] 100 + Box::new(Draw::new(x, y.into(), bytes)) [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 100 - Box::new(Draw::new(x.into(), y.into(), bytes)) [INFO] [stdout] 100 + Box::new(Draw::new(>::into(x), y.into(), bytes)) [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stderr] warning: build failed, waiting for other jobs to finish... [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/commands/command_parser.rs:100:42 [INFO] [stdout] | [INFO] [stdout] 100 | Box::new(Draw::new(x.into(), y.into(), bytes)) [INFO] [stdout] | ^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 100 - Box::new(Draw::new(x.into(), y.into(), bytes)) [INFO] [stdout] 100 + Box::new(Draw::new(x.into(), y, bytes)) [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 100 - Box::new(Draw::new(x.into(), y.into(), bytes)) [INFO] [stdout] 100 + Box::new(Draw::new(x.into(), >::into(y), bytes)) [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: field `sound_timer` is never read [INFO] [stdout] --> src/main.rs:25:5 [INFO] [stdout] | [INFO] [stdout] 18 | struct Chip8 { [INFO] [stdout] | ----- field in this struct [INFO] [stdout] ... [INFO] [stdout] 25 | sound_timer: u8, [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: `u8` [INFO] [stdout] --> src/chip8_commands.rs:42:52 [INFO] [stdout] | [INFO] [stdout] 42 | 3 => Chip8Commands::SkipEqualX(x.into(), command[1]), [INFO] [stdout] | ^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] = note: `#[deny(self_type_conversion)]` on by default [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 42 - 3 => Chip8Commands::SkipEqualX(x.into(), command[1]), [INFO] [stdout] 42 + 3 => Chip8Commands::SkipEqualX(x, command[1]), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 42 - 3 => Chip8Commands::SkipEqualX(x.into(), command[1]), [INFO] [stdout] 42 + 3 => Chip8Commands::SkipEqualX(>::into(x), command[1]), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/chip8_commands.rs:43:55 [INFO] [stdout] | [INFO] [stdout] 43 | 4 => Chip8Commands::SkipNotEqualX(x.into(), command[1]), [INFO] [stdout] | ^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 43 - 4 => Chip8Commands::SkipNotEqualX(x.into(), command[1]), [INFO] [stdout] 43 + 4 => Chip8Commands::SkipNotEqualX(x, command[1]), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 43 - 4 => Chip8Commands::SkipNotEqualX(x.into(), command[1]), [INFO] [stdout] 43 + 4 => Chip8Commands::SkipNotEqualX(>::into(x), command[1]), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/chip8_commands.rs:44:53 [INFO] [stdout] | [INFO] [stdout] 44 | 6 => Chip8Commands::SetRegister(x.into(), command[1]), [INFO] [stdout] | ^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 44 - 6 => Chip8Commands::SetRegister(x.into(), command[1]), [INFO] [stdout] 44 + 6 => Chip8Commands::SetRegister(x, command[1]), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 44 - 6 => Chip8Commands::SetRegister(x.into(), command[1]), [INFO] [stdout] 44 + 6 => Chip8Commands::SetRegister(>::into(x), command[1]), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/chip8_commands.rs:45:60 [INFO] [stdout] | [INFO] [stdout] 45 | 7 => Chip8Commands::AddValueToRegister(x.into(), command[1]), [INFO] [stdout] | ^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 45 - 7 => Chip8Commands::AddValueToRegister(x.into(), command[1]), [INFO] [stdout] 45 + 7 => Chip8Commands::AddValueToRegister(x, command[1]), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 45 - 7 => Chip8Commands::AddValueToRegister(x.into(), command[1]), [INFO] [stdout] 45 + 7 => Chip8Commands::AddValueToRegister(>::into(x), command[1]), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/chip8_commands.rs:54:48 [INFO] [stdout] | [INFO] [stdout] 54 | 0x0 => Chip8Commands::Load(x.into(), y.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] 54 - 0x0 => Chip8Commands::Load(x.into(), y.into()), [INFO] [stdout] 54 + 0x0 => Chip8Commands::Load(x, y.into()), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 54 - 0x0 => Chip8Commands::Load(x.into(), y.into()), [INFO] [stdout] 54 + 0x0 => Chip8Commands::Load(>::into(x), y.into()), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/chip8_commands.rs:54:58 [INFO] [stdout] | [INFO] [stdout] 54 | 0x0 => Chip8Commands::Load(x.into(), y.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] 54 - 0x0 => Chip8Commands::Load(x.into(), y.into()), [INFO] [stdout] 54 + 0x0 => Chip8Commands::Load(x.into(), y), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 54 - 0x0 => Chip8Commands::Load(x.into(), y.into()), [INFO] [stdout] 54 + 0x0 => Chip8Commands::Load(x.into(), >::into(y)), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/chip8_commands.rs:55:46 [INFO] [stdout] | [INFO] [stdout] 55 | 0x1 => Chip8Commands::OR(x.into(), y.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] 55 - 0x1 => Chip8Commands::OR(x.into(), y.into()), [INFO] [stdout] 55 + 0x1 => Chip8Commands::OR(x, y.into()), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 55 - 0x1 => Chip8Commands::OR(x.into(), y.into()), [INFO] [stdout] 55 + 0x1 => Chip8Commands::OR(>::into(x), y.into()), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/chip8_commands.rs:55:56 [INFO] [stdout] | [INFO] [stdout] 55 | 0x1 => Chip8Commands::OR(x.into(), y.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] 55 - 0x1 => Chip8Commands::OR(x.into(), y.into()), [INFO] [stdout] 55 + 0x1 => Chip8Commands::OR(x.into(), y), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 55 - 0x1 => Chip8Commands::OR(x.into(), y.into()), [INFO] [stdout] 55 + 0x1 => Chip8Commands::OR(x.into(), >::into(y)), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/chip8_commands.rs:56:47 [INFO] [stdout] | [INFO] [stdout] 56 | 0x2 => Chip8Commands::AND(x.into(), y.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] 56 - 0x2 => Chip8Commands::AND(x.into(), y.into()), [INFO] [stdout] 56 + 0x2 => Chip8Commands::AND(x, y.into()), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 56 - 0x2 => Chip8Commands::AND(x.into(), y.into()), [INFO] [stdout] 56 + 0x2 => Chip8Commands::AND(>::into(x), y.into()), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/chip8_commands.rs:56:57 [INFO] [stdout] | [INFO] [stdout] 56 | 0x2 => Chip8Commands::AND(x.into(), y.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] 56 - 0x2 => Chip8Commands::AND(x.into(), y.into()), [INFO] [stdout] 56 + 0x2 => Chip8Commands::AND(x.into(), y), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 56 - 0x2 => Chip8Commands::AND(x.into(), y.into()), [INFO] [stdout] 56 + 0x2 => Chip8Commands::AND(x.into(), >::into(y)), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/chip8_commands.rs:57:47 [INFO] [stdout] | [INFO] [stdout] 57 | 0x3 => Chip8Commands::XOR(x.into(), y.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] 57 - 0x3 => Chip8Commands::XOR(x.into(), y.into()), [INFO] [stdout] 57 + 0x3 => Chip8Commands::XOR(x, y.into()), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 57 - 0x3 => Chip8Commands::XOR(x.into(), y.into()), [INFO] [stdout] 57 + 0x3 => Chip8Commands::XOR(>::into(x), y.into()), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/chip8_commands.rs:57:57 [INFO] [stdout] | [INFO] [stdout] 57 | 0x3 => Chip8Commands::XOR(x.into(), y.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] 57 - 0x3 => Chip8Commands::XOR(x.into(), y.into()), [INFO] [stdout] 57 + 0x3 => Chip8Commands::XOR(x.into(), y), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 57 - 0x3 => Chip8Commands::XOR(x.into(), y.into()), [INFO] [stdout] 57 + 0x3 => Chip8Commands::XOR(x.into(), >::into(y)), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/chip8_commands.rs:58:47 [INFO] [stdout] | [INFO] [stdout] 58 | 0x4 => Chip8Commands::ADD(x.into(), y.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] 58 - 0x4 => Chip8Commands::ADD(x.into(), y.into()), [INFO] [stdout] 58 + 0x4 => Chip8Commands::ADD(x, y.into()), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 58 - 0x4 => Chip8Commands::ADD(x.into(), y.into()), [INFO] [stdout] 58 + 0x4 => Chip8Commands::ADD(>::into(x), y.into()), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/chip8_commands.rs:58:57 [INFO] [stdout] | [INFO] [stdout] 58 | 0x4 => Chip8Commands::ADD(x.into(), y.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] 58 - 0x4 => Chip8Commands::ADD(x.into(), y.into()), [INFO] [stdout] 58 + 0x4 => Chip8Commands::ADD(x.into(), y), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 58 - 0x4 => Chip8Commands::ADD(x.into(), y.into()), [INFO] [stdout] 58 + 0x4 => Chip8Commands::ADD(x.into(), >::into(y)), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/chip8_commands.rs:59:47 [INFO] [stdout] | [INFO] [stdout] 59 | 0x5 => Chip8Commands::SUB(x.into(), y.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] 59 - 0x5 => Chip8Commands::SUB(x.into(), y.into()), [INFO] [stdout] 59 + 0x5 => Chip8Commands::SUB(x, y.into()), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 59 - 0x5 => Chip8Commands::SUB(x.into(), y.into()), [INFO] [stdout] 59 + 0x5 => Chip8Commands::SUB(>::into(x), y.into()), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/chip8_commands.rs:59:57 [INFO] [stdout] | [INFO] [stdout] 59 | 0x5 => Chip8Commands::SUB(x.into(), y.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] 59 - 0x5 => Chip8Commands::SUB(x.into(), y.into()), [INFO] [stdout] 59 + 0x5 => Chip8Commands::SUB(x.into(), y), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 59 - 0x5 => Chip8Commands::SUB(x.into(), y.into()), [INFO] [stdout] 59 + 0x5 => Chip8Commands::SUB(x.into(), >::into(y)), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/chip8_commands.rs:60:54 [INFO] [stdout] | [INFO] [stdout] 60 | 0x6 => Chip8Commands::ShiftRight(x.into(), y.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] 60 - 0x6 => Chip8Commands::ShiftRight(x.into(), y.into()), [INFO] [stdout] 60 + 0x6 => Chip8Commands::ShiftRight(x, y.into()), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 60 - 0x6 => Chip8Commands::ShiftRight(x.into(), y.into()), [INFO] [stdout] 60 + 0x6 => Chip8Commands::ShiftRight(>::into(x), y.into()), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/chip8_commands.rs:60:64 [INFO] [stdout] | [INFO] [stdout] 60 | 0x6 => Chip8Commands::ShiftRight(x.into(), y.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] 60 - 0x6 => Chip8Commands::ShiftRight(x.into(), y.into()), [INFO] [stdout] 60 + 0x6 => Chip8Commands::ShiftRight(x.into(), y), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 60 - 0x6 => Chip8Commands::ShiftRight(x.into(), y.into()), [INFO] [stdout] 60 + 0x6 => Chip8Commands::ShiftRight(x.into(), >::into(y)), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/chip8_commands.rs:61:48 [INFO] [stdout] | [INFO] [stdout] 61 | 0x7 => Chip8Commands::SUBN(x.into(), y.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] 61 - 0x7 => Chip8Commands::SUBN(x.into(), y.into()), [INFO] [stdout] 61 + 0x7 => Chip8Commands::SUBN(x, y.into()), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 61 - 0x7 => Chip8Commands::SUBN(x.into(), y.into()), [INFO] [stdout] 61 + 0x7 => Chip8Commands::SUBN(>::into(x), y.into()), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/chip8_commands.rs:61:58 [INFO] [stdout] | [INFO] [stdout] 61 | 0x7 => Chip8Commands::SUBN(x.into(), y.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] 61 - 0x7 => Chip8Commands::SUBN(x.into(), y.into()), [INFO] [stdout] 61 + 0x7 => Chip8Commands::SUBN(x.into(), y), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 61 - 0x7 => Chip8Commands::SUBN(x.into(), y.into()), [INFO] [stdout] 61 + 0x7 => Chip8Commands::SUBN(x.into(), >::into(y)), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/chip8_commands.rs:62:53 [INFO] [stdout] | [INFO] [stdout] 62 | 0xE => Chip8Commands::ShiftLeft(x.into(), y.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] 62 - 0xE => Chip8Commands::ShiftLeft(x.into(), y.into()), [INFO] [stdout] 62 + 0xE => Chip8Commands::ShiftLeft(x, y.into()), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 62 - 0xE => Chip8Commands::ShiftLeft(x.into(), y.into()), [INFO] [stdout] 62 + 0xE => Chip8Commands::ShiftLeft(>::into(x), y.into()), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/chip8_commands.rs:62:63 [INFO] [stdout] | [INFO] [stdout] 62 | 0xE => Chip8Commands::ShiftLeft(x.into(), y.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] 62 - 0xE => Chip8Commands::ShiftLeft(x.into(), y.into()), [INFO] [stdout] 62 + 0xE => Chip8Commands::ShiftLeft(x.into(), y), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 62 - 0xE => Chip8Commands::ShiftLeft(x.into(), y.into()), [INFO] [stdout] 62 + 0xE => Chip8Commands::ShiftLeft(x.into(), >::into(y)), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/chip8_commands.rs:69:55 [INFO] [stdout] | [INFO] [stdout] 69 | 0x1E => Chip8Commands::AddToIndex(x.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] 69 - 0x1E => Chip8Commands::AddToIndex(x.into()), [INFO] [stdout] 69 + 0x1E => Chip8Commands::AddToIndex(x), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 69 - 0x1E => Chip8Commands::AddToIndex(x.into()), [INFO] [stdout] 69 + 0x1E => Chip8Commands::AddToIndex(>::into(x)), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/chip8_commands.rs:70:63 [INFO] [stdout] | [INFO] [stdout] 70 | 0x33 => Chip8Commands::BinaryCodedDecimal(x.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] 70 - 0x33 => Chip8Commands::BinaryCodedDecimal(x.into()), [INFO] [stdout] 70 + 0x33 => Chip8Commands::BinaryCodedDecimal(x), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 70 - 0x33 => Chip8Commands::BinaryCodedDecimal(x.into()), [INFO] [stdout] 70 + 0x33 => Chip8Commands::BinaryCodedDecimal(>::into(x)), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/chip8_commands.rs:71:59 [INFO] [stdout] | [INFO] [stdout] 71 | 0x55 => Chip8Commands::StoreRegisters(x.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] 71 - 0x55 => Chip8Commands::StoreRegisters(x.into()), [INFO] [stdout] 71 + 0x55 => Chip8Commands::StoreRegisters(x), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 71 - 0x55 => Chip8Commands::StoreRegisters(x.into()), [INFO] [stdout] 71 + 0x55 => Chip8Commands::StoreRegisters(>::into(x)), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/chip8_commands.rs:72:62 [INFO] [stdout] | [INFO] [stdout] 72 | 0x65 => Chip8Commands::ReadIntoRegisters(x.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] 72 - 0x65 => Chip8Commands::ReadIntoRegisters(x.into()), [INFO] [stdout] 72 + 0x65 => Chip8Commands::ReadIntoRegisters(x), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 72 - 0x65 => Chip8Commands::ReadIntoRegisters(x.into()), [INFO] [stdout] 72 + 0x65 => Chip8Commands::ReadIntoRegisters(>::into(x)), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/chip8_commands.rs:88:44 [INFO] [stdout] | [INFO] [stdout] 88 | Chip8Commands::SkipEqualXY(x.into(), y.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] 88 - Chip8Commands::SkipEqualXY(x.into(), y.into()) [INFO] [stdout] 88 + Chip8Commands::SkipEqualXY(x, y.into()) [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 88 - Chip8Commands::SkipEqualXY(x.into(), y.into()) [INFO] [stdout] 88 + Chip8Commands::SkipEqualXY(>::into(x), y.into()) [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/chip8_commands.rs:88:54 [INFO] [stdout] | [INFO] [stdout] 88 | Chip8Commands::SkipEqualXY(x.into(), y.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] 88 - Chip8Commands::SkipEqualXY(x.into(), y.into()) [INFO] [stdout] 88 + Chip8Commands::SkipEqualXY(x.into(), y) [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 88 - Chip8Commands::SkipEqualXY(x.into(), y.into()) [INFO] [stdout] 88 + Chip8Commands::SkipEqualXY(x.into(), >::into(y)) [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/chip8_commands.rs:93:47 [INFO] [stdout] | [INFO] [stdout] 93 | Chip8Commands::SkipNotEqualXY(x.into(), y.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] 93 - Chip8Commands::SkipNotEqualXY(x.into(), y.into()) [INFO] [stdout] 93 + Chip8Commands::SkipNotEqualXY(x, y.into()) [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 93 - Chip8Commands::SkipNotEqualXY(x.into(), y.into()) [INFO] [stdout] 93 + Chip8Commands::SkipNotEqualXY(>::into(x), y.into()) [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/chip8_commands.rs:93:57 [INFO] [stdout] | [INFO] [stdout] 93 | Chip8Commands::SkipNotEqualXY(x.into(), y.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] 93 - Chip8Commands::SkipNotEqualXY(x.into(), y.into()) [INFO] [stdout] 93 + Chip8Commands::SkipNotEqualXY(x.into(), y) [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 93 - Chip8Commands::SkipNotEqualXY(x.into(), y.into()) [INFO] [stdout] 93 + Chip8Commands::SkipNotEqualXY(x.into(), >::into(y)) [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/chip8_commands.rs:99:37 [INFO] [stdout] | [INFO] [stdout] 99 | Chip8Commands::Draw(x.into(), y.into(), bytes) [INFO] [stdout] | ^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 99 - Chip8Commands::Draw(x.into(), y.into(), bytes) [INFO] [stdout] 99 + Chip8Commands::Draw(x, y.into(), bytes) [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 99 - Chip8Commands::Draw(x.into(), y.into(), bytes) [INFO] [stdout] 99 + Chip8Commands::Draw(>::into(x), y.into(), bytes) [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/chip8_commands.rs:99:47 [INFO] [stdout] | [INFO] [stdout] 99 | Chip8Commands::Draw(x.into(), y.into(), bytes) [INFO] [stdout] | ^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 99 - Chip8Commands::Draw(x.into(), y.into(), bytes) [INFO] [stdout] 99 + Chip8Commands::Draw(x.into(), y, bytes) [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 99 - Chip8Commands::Draw(x.into(), y.into(), bytes) [INFO] [stdout] 99 + Chip8Commands::Draw(x.into(), >::into(y), bytes) [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/commands/command_parser.rs:42:50 [INFO] [stdout] | [INFO] [stdout] 42 | 4 => Box::new(SkipNotEqualX::new(x.into(), command[1])), [INFO] [stdout] | ^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 42 - 4 => Box::new(SkipNotEqualX::new(x.into(), command[1])), [INFO] [stdout] 42 + 4 => Box::new(SkipNotEqualX::new(x, command[1])), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 42 - 4 => Box::new(SkipNotEqualX::new(x.into(), command[1])), [INFO] [stdout] 42 + 4 => Box::new(SkipNotEqualX::new(>::into(x), command[1])), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/commands/command_parser.rs:43:48 [INFO] [stdout] | [INFO] [stdout] 43 | 6 => Box::new(SetRegister::new(x.into(), command[1])), [INFO] [stdout] | ^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 43 - 6 => Box::new(SetRegister::new(x.into(), command[1])), [INFO] [stdout] 43 + 6 => Box::new(SetRegister::new(x, command[1])), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 43 - 6 => Box::new(SetRegister::new(x.into(), command[1])), [INFO] [stdout] 43 + 6 => Box::new(SetRegister::new(>::into(x), command[1])), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/commands/command_parser.rs:44:55 [INFO] [stdout] | [INFO] [stdout] 44 | 7 => Box::new(AddValueToRegister::new(x.into(), command[1])), [INFO] [stdout] | ^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 44 - 7 => Box::new(AddValueToRegister::new(x.into(), command[1])), [INFO] [stdout] 44 + 7 => Box::new(AddValueToRegister::new(x, command[1])), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 44 - 7 => Box::new(AddValueToRegister::new(x.into(), command[1])), [INFO] [stdout] 44 + 7 => Box::new(AddValueToRegister::new(>::into(x), command[1])), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/commands/command_parser.rs:53:43 [INFO] [stdout] | [INFO] [stdout] 53 | 0x0 => Box::new(Load::new(x.into(), y.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] 53 - 0x0 => Box::new(Load::new(x.into(), y.into())), [INFO] [stdout] 53 + 0x0 => Box::new(Load::new(x, y.into())), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 53 - 0x0 => Box::new(Load::new(x.into(), y.into())), [INFO] [stdout] 53 + 0x0 => Box::new(Load::new(>::into(x), y.into())), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/commands/command_parser.rs:53:53 [INFO] [stdout] | [INFO] [stdout] 53 | 0x0 => Box::new(Load::new(x.into(), y.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] 53 - 0x0 => Box::new(Load::new(x.into(), y.into())), [INFO] [stdout] 53 + 0x0 => Box::new(Load::new(x.into(), y)), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 53 - 0x0 => Box::new(Load::new(x.into(), y.into())), [INFO] [stdout] 53 + 0x0 => Box::new(Load::new(x.into(), >::into(y))), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/commands/command_parser.rs:54:41 [INFO] [stdout] | [INFO] [stdout] 54 | 0x1 => Box::new(Or::new(x.into(), y.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] 54 - 0x1 => Box::new(Or::new(x.into(), y.into())), [INFO] [stdout] 54 + 0x1 => Box::new(Or::new(x, y.into())), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 54 - 0x1 => Box::new(Or::new(x.into(), y.into())), [INFO] [stdout] 54 + 0x1 => Box::new(Or::new(>::into(x), y.into())), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/commands/command_parser.rs:54:51 [INFO] [stdout] | [INFO] [stdout] 54 | 0x1 => Box::new(Or::new(x.into(), y.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] 54 - 0x1 => Box::new(Or::new(x.into(), y.into())), [INFO] [stdout] 54 + 0x1 => Box::new(Or::new(x.into(), y)), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 54 - 0x1 => Box::new(Or::new(x.into(), y.into())), [INFO] [stdout] 54 + 0x1 => Box::new(Or::new(x.into(), >::into(y))), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/commands/command_parser.rs:55:42 [INFO] [stdout] | [INFO] [stdout] 55 | 0x2 => Box::new(And::new(x.into(), y.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] 55 - 0x2 => Box::new(And::new(x.into(), y.into())), [INFO] [stdout] 55 + 0x2 => Box::new(And::new(x, y.into())), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 55 - 0x2 => Box::new(And::new(x.into(), y.into())), [INFO] [stdout] 55 + 0x2 => Box::new(And::new(>::into(x), y.into())), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/commands/command_parser.rs:55:52 [INFO] [stdout] | [INFO] [stdout] 55 | 0x2 => Box::new(And::new(x.into(), y.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] 55 - 0x2 => Box::new(And::new(x.into(), y.into())), [INFO] [stdout] 55 + 0x2 => Box::new(And::new(x.into(), y)), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 55 - 0x2 => Box::new(And::new(x.into(), y.into())), [INFO] [stdout] 55 + 0x2 => Box::new(And::new(x.into(), >::into(y))), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/commands/command_parser.rs:56:42 [INFO] [stdout] | [INFO] [stdout] 56 | 0x3 => Box::new(Xor::new(x.into(), y.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] 56 - 0x3 => Box::new(Xor::new(x.into(), y.into())), [INFO] [stdout] 56 + 0x3 => Box::new(Xor::new(x, y.into())), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 56 - 0x3 => Box::new(Xor::new(x.into(), y.into())), [INFO] [stdout] 56 + 0x3 => Box::new(Xor::new(>::into(x), y.into())), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/commands/command_parser.rs:56:52 [INFO] [stdout] | [INFO] [stdout] 56 | 0x3 => Box::new(Xor::new(x.into(), y.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] 56 - 0x3 => Box::new(Xor::new(x.into(), y.into())), [INFO] [stdout] 56 + 0x3 => Box::new(Xor::new(x.into(), y)), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 56 - 0x3 => Box::new(Xor::new(x.into(), y.into())), [INFO] [stdout] 56 + 0x3 => Box::new(Xor::new(x.into(), >::into(y))), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/commands/command_parser.rs:57:42 [INFO] [stdout] | [INFO] [stdout] 57 | 0x4 => Box::new(Add::new(x.into(), y.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] 57 - 0x4 => Box::new(Add::new(x.into(), y.into())), [INFO] [stdout] 57 + 0x4 => Box::new(Add::new(x, y.into())), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 57 - 0x4 => Box::new(Add::new(x.into(), y.into())), [INFO] [stdout] 57 + 0x4 => Box::new(Add::new(>::into(x), y.into())), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/commands/command_parser.rs:57:52 [INFO] [stdout] | [INFO] [stdout] 57 | 0x4 => Box::new(Add::new(x.into(), y.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] 57 - 0x4 => Box::new(Add::new(x.into(), y.into())), [INFO] [stdout] 57 + 0x4 => Box::new(Add::new(x.into(), y)), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 57 - 0x4 => Box::new(Add::new(x.into(), y.into())), [INFO] [stdout] 57 + 0x4 => Box::new(Add::new(x.into(), >::into(y))), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/commands/command_parser.rs:58:42 [INFO] [stdout] | [INFO] [stdout] 58 | 0x5 => Box::new(Sub::new(x.into(), y.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] 58 - 0x5 => Box::new(Sub::new(x.into(), y.into())), [INFO] [stdout] 58 + 0x5 => Box::new(Sub::new(x, y.into())), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 58 - 0x5 => Box::new(Sub::new(x.into(), y.into())), [INFO] [stdout] 58 + 0x5 => Box::new(Sub::new(>::into(x), y.into())), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/commands/command_parser.rs:58:52 [INFO] [stdout] | [INFO] [stdout] 58 | 0x5 => Box::new(Sub::new(x.into(), y.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] 58 - 0x5 => Box::new(Sub::new(x.into(), y.into())), [INFO] [stdout] 58 + 0x5 => Box::new(Sub::new(x.into(), y)), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 58 - 0x5 => Box::new(Sub::new(x.into(), y.into())), [INFO] [stdout] 58 + 0x5 => Box::new(Sub::new(x.into(), >::into(y))), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/commands/command_parser.rs:59:49 [INFO] [stdout] | [INFO] [stdout] 59 | 0x6 => Box::new(ShiftRight::new(x.into(), y.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] 59 - 0x6 => Box::new(ShiftRight::new(x.into(), y.into())), [INFO] [stdout] 59 + 0x6 => Box::new(ShiftRight::new(x, y.into())), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 59 - 0x6 => Box::new(ShiftRight::new(x.into(), y.into())), [INFO] [stdout] 59 + 0x6 => Box::new(ShiftRight::new(>::into(x), y.into())), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/commands/command_parser.rs:59:59 [INFO] [stdout] | [INFO] [stdout] 59 | 0x6 => Box::new(ShiftRight::new(x.into(), y.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] 59 - 0x6 => Box::new(ShiftRight::new(x.into(), y.into())), [INFO] [stdout] 59 + 0x6 => Box::new(ShiftRight::new(x.into(), y)), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 59 - 0x6 => Box::new(ShiftRight::new(x.into(), y.into())), [INFO] [stdout] 59 + 0x6 => Box::new(ShiftRight::new(x.into(), >::into(y))), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/commands/command_parser.rs:60:43 [INFO] [stdout] | [INFO] [stdout] 60 | 0x7 => Box::new(SubN::new(x.into(), y.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] 60 - 0x7 => Box::new(SubN::new(x.into(), y.into())), [INFO] [stdout] 60 + 0x7 => Box::new(SubN::new(x, y.into())), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 60 - 0x7 => Box::new(SubN::new(x.into(), y.into())), [INFO] [stdout] 60 + 0x7 => Box::new(SubN::new(>::into(x), y.into())), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/commands/command_parser.rs:60:53 [INFO] [stdout] | [INFO] [stdout] 60 | 0x7 => Box::new(SubN::new(x.into(), y.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] 60 - 0x7 => Box::new(SubN::new(x.into(), y.into())), [INFO] [stdout] 60 + 0x7 => Box::new(SubN::new(x.into(), y)), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 60 - 0x7 => Box::new(SubN::new(x.into(), y.into())), [INFO] [stdout] 60 + 0x7 => Box::new(SubN::new(x.into(), >::into(y))), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/commands/command_parser.rs:61:48 [INFO] [stdout] | [INFO] [stdout] 61 | 0xE => Box::new(ShiftLeft::new(x.into(), y.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] 61 - 0xE => Box::new(ShiftLeft::new(x.into(), y.into())), [INFO] [stdout] 61 + 0xE => Box::new(ShiftLeft::new(x, y.into())), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 61 - 0xE => Box::new(ShiftLeft::new(x.into(), y.into())), [INFO] [stdout] 61 + 0xE => Box::new(ShiftLeft::new(>::into(x), y.into())), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/commands/command_parser.rs:61:58 [INFO] [stdout] | [INFO] [stdout] 61 | 0xE => Box::new(ShiftLeft::new(x.into(), y.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] 61 - 0xE => Box::new(ShiftLeft::new(x.into(), y.into())), [INFO] [stdout] 61 + 0xE => Box::new(ShiftLeft::new(x.into(), y)), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 61 - 0xE => Box::new(ShiftLeft::new(x.into(), y.into())), [INFO] [stdout] 61 + 0xE => Box::new(ShiftLeft::new(x.into(), >::into(y))), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/commands/command_parser.rs:68:60 [INFO] [stdout] | [INFO] [stdout] 68 | 0x07 => Box::new(SetRegisterFromDelay::new(x.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] 68 - 0x07 => Box::new(SetRegisterFromDelay::new(x.into())), [INFO] [stdout] 68 + 0x07 => Box::new(SetRegisterFromDelay::new(x)), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 68 - 0x07 => Box::new(SetRegisterFromDelay::new(x.into())), [INFO] [stdout] 68 + 0x07 => Box::new(SetRegisterFromDelay::new(>::into(x))), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/commands/command_parser.rs:69:53 [INFO] [stdout] | [INFO] [stdout] 69 | 0x15 => Box::new(SetDelayTimer::new(x.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] 69 - 0x15 => Box::new(SetDelayTimer::new(x.into())), [INFO] [stdout] 69 + 0x15 => Box::new(SetDelayTimer::new(x)), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 69 - 0x15 => Box::new(SetDelayTimer::new(x.into())), [INFO] [stdout] 69 + 0x15 => Box::new(SetDelayTimer::new(>::into(x))), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/commands/command_parser.rs:70:50 [INFO] [stdout] | [INFO] [stdout] 70 | 0x1E => Box::new(AddToIndex::new(x.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] 70 - 0x1E => Box::new(AddToIndex::new(x.into())), [INFO] [stdout] 70 + 0x1E => Box::new(AddToIndex::new(x)), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 70 - 0x1E => Box::new(AddToIndex::new(x.into())), [INFO] [stdout] 70 + 0x1E => Box::new(AddToIndex::new(>::into(x))), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/commands/command_parser.rs:71:58 [INFO] [stdout] | [INFO] [stdout] 71 | 0x33 => Box::new(BinaryCodedDecimal::new(x.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] 71 - 0x33 => Box::new(BinaryCodedDecimal::new(x.into())), [INFO] [stdout] 71 + 0x33 => Box::new(BinaryCodedDecimal::new(x)), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 71 - 0x33 => Box::new(BinaryCodedDecimal::new(x.into())), [INFO] [stdout] 71 + 0x33 => Box::new(BinaryCodedDecimal::new(>::into(x))), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/commands/command_parser.rs:72:54 [INFO] [stdout] | [INFO] [stdout] 72 | 0x55 => Box::new(StoreRegisters::new(x.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] 72 - 0x55 => Box::new(StoreRegisters::new(x.into())), [INFO] [stdout] 72 + 0x55 => Box::new(StoreRegisters::new(x)), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 72 - 0x55 => Box::new(StoreRegisters::new(x.into())), [INFO] [stdout] 72 + 0x55 => Box::new(StoreRegisters::new(>::into(x))), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/commands/command_parser.rs:73:57 [INFO] [stdout] | [INFO] [stdout] 73 | 0x65 => Box::new(ReadIntoRegisters::new(x.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] 73 - 0x65 => Box::new(ReadIntoRegisters::new(x.into())), [INFO] [stdout] 73 + 0x65 => Box::new(ReadIntoRegisters::new(x)), [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 73 - 0x65 => Box::new(ReadIntoRegisters::new(x.into())), [INFO] [stdout] 73 + 0x65 => Box::new(ReadIntoRegisters::new(>::into(x))), [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/commands/command_parser.rs:89:39 [INFO] [stdout] | [INFO] [stdout] 89 | Box::new(SkipEqualXY::new(x.into(), y.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] 89 - Box::new(SkipEqualXY::new(x.into(), y.into())) [INFO] [stdout] 89 + Box::new(SkipEqualXY::new(x, y.into())) [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 89 - Box::new(SkipEqualXY::new(x.into(), y.into())) [INFO] [stdout] 89 + Box::new(SkipEqualXY::new(>::into(x), y.into())) [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/commands/command_parser.rs:89:49 [INFO] [stdout] | [INFO] [stdout] 89 | Box::new(SkipEqualXY::new(x.into(), y.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] 89 - Box::new(SkipEqualXY::new(x.into(), y.into())) [INFO] [stdout] 89 + Box::new(SkipEqualXY::new(x.into(), y)) [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 89 - Box::new(SkipEqualXY::new(x.into(), y.into())) [INFO] [stdout] 89 + Box::new(SkipEqualXY::new(x.into(), >::into(y))) [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/commands/command_parser.rs:94:42 [INFO] [stdout] | [INFO] [stdout] 94 | Box::new(SkipNotEqualXY::new(x.into(), y.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] 94 - Box::new(SkipNotEqualXY::new(x.into(), y.into())) [INFO] [stdout] 94 + Box::new(SkipNotEqualXY::new(x, y.into())) [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 94 - Box::new(SkipNotEqualXY::new(x.into(), y.into())) [INFO] [stdout] 94 + Box::new(SkipNotEqualXY::new(>::into(x), y.into())) [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/commands/command_parser.rs:94:52 [INFO] [stdout] | [INFO] [stdout] 94 | Box::new(SkipNotEqualXY::new(x.into(), y.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] 94 - Box::new(SkipNotEqualXY::new(x.into(), y.into())) [INFO] [stdout] 94 + Box::new(SkipNotEqualXY::new(x.into(), y)) [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 94 - Box::new(SkipNotEqualXY::new(x.into(), y.into())) [INFO] [stdout] 94 + Box::new(SkipNotEqualXY::new(x.into(), >::into(y))) [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/commands/command_parser.rs:100:32 [INFO] [stdout] | [INFO] [stdout] 100 | Box::new(Draw::new(x.into(), y.into(), bytes)) [INFO] [stdout] | ^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 100 - Box::new(Draw::new(x.into(), y.into(), bytes)) [INFO] [stdout] 100 + Box::new(Draw::new(x, y.into(), bytes)) [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 100 - Box::new(Draw::new(x.into(), y.into(), bytes)) [INFO] [stdout] 100 + Box::new(Draw::new(>::into(x), y.into(), bytes)) [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] error: useless conversion to the same type: `u8` [INFO] [stdout] --> src/commands/command_parser.rs:100:42 [INFO] [stdout] | [INFO] [stdout] 100 | Box::new(Draw::new(x.into(), y.into(), bytes)) [INFO] [stdout] | ^^^^^^^^ [INFO] [stdout] | [INFO] [stdout] = note: this method call relies on the `impl Into for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors [INFO] [stdout] help: consider removing the conversion call [INFO] [stdout] | [INFO] [stdout] 100 - Box::new(Draw::new(x.into(), y.into(), bytes)) [INFO] [stdout] 100 + Box::new(Draw::new(x.into(), y, bytes)) [INFO] [stdout] | [INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint [INFO] [stdout] | [INFO] [stdout] 100 - Box::new(Draw::new(x.into(), y.into(), bytes)) [INFO] [stdout] 100 + Box::new(Draw::new(x.into(), >::into(y), bytes)) [INFO] [stdout] | [INFO] [stdout] [INFO] [stdout] [INFO] [stderr] error: could not compile `chip8` (bin "chip8" test) due to 65 previous errors; 2 warnings emitted [INFO] running `Command { std: "docker" "inspect" "9438ab75c93a386a6065dff06743c8b7ec9dbd37839e531dfe5d763a08aa1eb9", kill_on_drop: false }` [INFO] running `Command { std: "docker" "rm" "-f" "9438ab75c93a386a6065dff06743c8b7ec9dbd37839e531dfe5d763a08aa1eb9", kill_on_drop: false }` [INFO] [stdout] 9438ab75c93a386a6065dff06743c8b7ec9dbd37839e531dfe5d763a08aa1eb9