[INFO] cloning repository https://github.com/panzi/rust-varint [INFO] running `Command { std: "git" "-c" "credential.helper=" "-c" "credential.helper=/workspace/cargo-home/bin/git-credential-null" "clone" "--bare" "https://github.com/panzi/rust-varint" "/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2Fpanzi%2Frust-varint", kill_on_drop: false }` [INFO] [stderr] Cloning into bare repository '/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2Fpanzi%2Frust-varint'... [INFO] running `Command { std: "git" "rev-parse" "HEAD", kill_on_drop: false }` [INFO] [stdout] 3f90fab2a55674cdbad9f39a6a76383df24ded6a [INFO] checking panzi/rust-varint against try#b32fc44666c052e7cf07ab471bfb6f9ec571902f for pr-138676 [INFO] running `Command { std: "git" "clone" "/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2Fpanzi%2Frust-varint" "/workspace/builds/worker-3-tc2/source", kill_on_drop: false }` [INFO] [stderr] Cloning into '/workspace/builds/worker-3-tc2/source'... [INFO] [stderr] done. [INFO] validating manifest of git repo https://github.com/panzi/rust-varint on toolchain b32fc44666c052e7cf07ab471bfb6f9ec571902f [INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+b32fc44666c052e7cf07ab471bfb6f9ec571902f" "metadata" "--manifest-path" "Cargo.toml" "--no-deps", kill_on_drop: false }` [INFO] started tweaking git repo https://github.com/panzi/rust-varint [INFO] finished tweaking git repo https://github.com/panzi/rust-varint [INFO] tweaked toml for git repo https://github.com/panzi/rust-varint written to /workspace/builds/worker-3-tc2/source/Cargo.toml [INFO] crate git repo https://github.com/panzi/rust-varint 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" "+b32fc44666c052e7cf07ab471bfb6f9ec571902f" "fetch" "--manifest-path" "Cargo.toml", kill_on_drop: false }` [INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-3-tc2/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-3-tc2/source:/opt/rustwide/workdir:ro,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" "-e" "SOURCE_DIR=/opt/rustwide/workdir" "-e" "CARGO_TARGET_DIR=/opt/rustwide/target" "-e" "CARGO_HOME=/opt/rustwide/cargo-home" "-e" "RUSTUP_HOME=/opt/rustwide/rustup-home" "-w" "/opt/rustwide/workdir" "-m" "1610612736" "--user" "0:0" "--network" "none" "ghcr.io/rust-lang/crates-build-env/linux@sha256:1680c8fbd8dfb46fcd6d22e546df16ab0e007457dc29fcd9e987cdd5077fd1af" "/opt/rustwide/cargo-home/bin/cargo" "+b32fc44666c052e7cf07ab471bfb6f9ec571902f" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }` [INFO] [stdout] 93de6c0901680e542d529fc815ddf648d198c5601323fbc2aac32c90473f3ac0 [INFO] running `Command { std: "docker" "start" "-a" "93de6c0901680e542d529fc815ddf648d198c5601323fbc2aac32c90473f3ac0", kill_on_drop: false }` [INFO] running `Command { std: "docker" "inspect" "93de6c0901680e542d529fc815ddf648d198c5601323fbc2aac32c90473f3ac0", kill_on_drop: false }` [INFO] running `Command { std: "docker" "rm" "-f" "93de6c0901680e542d529fc815ddf648d198c5601323fbc2aac32c90473f3ac0", kill_on_drop: false }` [INFO] [stdout] 93de6c0901680e542d529fc815ddf648d198c5601323fbc2aac32c90473f3ac0 [INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-3-tc2/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-3-tc2/source:/opt/rustwide/workdir:ro,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" "-e" "SOURCE_DIR=/opt/rustwide/workdir" "-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" "-e" "CARGO_HOME=/opt/rustwide/cargo-home" "-e" "RUSTUP_HOME=/opt/rustwide/rustup-home" "-w" "/opt/rustwide/workdir" "-m" "1610612736" "--user" "0:0" "--network" "none" "ghcr.io/rust-lang/crates-build-env/linux@sha256:1680c8fbd8dfb46fcd6d22e546df16ab0e007457dc29fcd9e987cdd5077fd1af" "/opt/rustwide/cargo-home/bin/cargo" "+b32fc44666c052e7cf07ab471bfb6f9ec571902f" "check" "--frozen" "--all" "--all-targets" "--message-format=json", kill_on_drop: false }` [INFO] [stdout] 02594318c546dbe68da2f56d28e4b7c9a5add6229c6449168a528ea6e6df2788 [INFO] running `Command { std: "docker" "start" "-a" "02594318c546dbe68da2f56d28e4b7c9a5add6229c6449168a528ea6e6df2788", kill_on_drop: false }` [INFO] [stderr] Checking varint v0.1.0 (/opt/rustwide/workdir) [INFO] [stdout] warning: irrefutable `if let` pattern [INFO] [stdout] --> src/varuint.rs:416:20 [INFO] [stdout] | [INFO] [stdout] 416 | if let Ok(value) = value.try_into() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 450 | / impl_varuint! { [INFO] [stdout] 451 | | u8 [1 2 3 4 5 6 7 8], [INFO] [stdout] 452 | | u16 [9 10 11 12 13 14 15 16], [INFO] [stdout] 453 | | u32 [17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32], [INFO] [stdout] 454 | | u64 [33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64], [INFO] [stdout] 455 | | u128 [65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 10... [INFO] [stdout] 456 | | } [INFO] [stdout] | |_- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this pattern will always match, so the `if let` is useless [INFO] [stdout] = help: consider replacing the `if let` with a `let` [INFO] [stdout] = note: `#[warn(irrefutable_let_patterns)]` on by default [INFO] [stdout] = note: this warning originates in the macro `impl_varuint` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: irrefutable `if let` pattern [INFO] [stdout] --> src/varuint.rs:416:20 [INFO] [stdout] | [INFO] [stdout] 416 | if let Ok(value) = value.try_into() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 450 | / impl_varuint! { [INFO] [stdout] 451 | | u8 [1 2 3 4 5 6 7 8], [INFO] [stdout] 452 | | u16 [9 10 11 12 13 14 15 16], [INFO] [stdout] 453 | | u32 [17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32], [INFO] [stdout] 454 | | u64 [33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64], [INFO] [stdout] 455 | | u128 [65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 10... [INFO] [stdout] 456 | | } [INFO] [stdout] | |_- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this pattern will always match, so the `if let` is useless [INFO] [stdout] = help: consider replacing the `if let` with a `let` [INFO] [stdout] = note: `#[warn(irrefutable_let_patterns)]` on by default [INFO] [stdout] = note: this warning originates in the macro `impl_varuint` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: irrefutable `if let` pattern [INFO] [stdout] --> src/varuint.rs:416:20 [INFO] [stdout] | [INFO] [stdout] 416 | if let Ok(value) = value.try_into() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 450 | / impl_varuint! { [INFO] [stdout] 451 | | u8 [1 2 3 4 5 6 7 8], [INFO] [stdout] 452 | | u16 [9 10 11 12 13 14 15 16], [INFO] [stdout] 453 | | u32 [17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32], [INFO] [stdout] 454 | | u64 [33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64], [INFO] [stdout] 455 | | u128 [65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 10... [INFO] [stdout] 456 | | } [INFO] [stdout] | |_- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this pattern will always match, so the `if let` is useless [INFO] [stdout] = help: consider replacing the `if let` with a `let` [INFO] [stdout] = note: this warning originates in the macro `impl_varuint` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: irrefutable `if let` pattern [INFO] [stdout] --> src/varuint.rs:416:20 [INFO] [stdout] | [INFO] [stdout] 416 | if let Ok(value) = value.try_into() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 450 | / impl_varuint! { [INFO] [stdout] 451 | | u8 [1 2 3 4 5 6 7 8], [INFO] [stdout] 452 | | u16 [9 10 11 12 13 14 15 16], [INFO] [stdout] 453 | | u32 [17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32], [INFO] [stdout] 454 | | u64 [33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64], [INFO] [stdout] 455 | | u128 [65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 10... [INFO] [stdout] 456 | | } [INFO] [stdout] | |_- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this pattern will always match, so the `if let` is useless [INFO] [stdout] = help: consider replacing the `if let` with a `let` [INFO] [stdout] = note: this warning originates in the macro `impl_varuint` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: irrefutable `if let` pattern [INFO] [stdout] --> src/varuint.rs:416:20 [INFO] [stdout] | [INFO] [stdout] 416 | if let Ok(value) = value.try_into() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 450 | / impl_varuint! { [INFO] [stdout] 451 | | u8 [1 2 3 4 5 6 7 8], [INFO] [stdout] 452 | | u16 [9 10 11 12 13 14 15 16], [INFO] [stdout] 453 | | u32 [17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32], [INFO] [stdout] 454 | | u64 [33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64], [INFO] [stdout] 455 | | u128 [65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 10... [INFO] [stdout] 456 | | } [INFO] [stdout] | |_- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this pattern will always match, so the `if let` is useless [INFO] [stdout] = help: consider replacing the `if let` with a `let` [INFO] [stdout] = note: this warning originates in the macro `impl_varuint` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: irrefutable `if let` pattern [INFO] [stdout] --> src/varuint.rs:416:20 [INFO] [stdout] | [INFO] [stdout] 416 | if let Ok(value) = value.try_into() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 450 | / impl_varuint! { [INFO] [stdout] 451 | | u8 [1 2 3 4 5 6 7 8], [INFO] [stdout] 452 | | u16 [9 10 11 12 13 14 15 16], [INFO] [stdout] 453 | | u32 [17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32], [INFO] [stdout] 454 | | u64 [33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64], [INFO] [stdout] 455 | | u128 [65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 10... [INFO] [stdout] 456 | | } [INFO] [stdout] | |_- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this pattern will always match, so the `if let` is useless [INFO] [stdout] = help: consider replacing the `if let` with a `let` [INFO] [stdout] = note: this warning originates in the macro `impl_varuint` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: irrefutable `if let` pattern [INFO] [stdout] --> src/varuint.rs:416:20 [INFO] [stdout] | [INFO] [stdout] 416 | if let Ok(value) = value.try_into() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 450 | / impl_varuint! { [INFO] [stdout] 451 | | u8 [1 2 3 4 5 6 7 8], [INFO] [stdout] 452 | | u16 [9 10 11 12 13 14 15 16], [INFO] [stdout] 453 | | u32 [17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32], [INFO] [stdout] 454 | | u64 [33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64], [INFO] [stdout] 455 | | u128 [65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 10... [INFO] [stdout] 456 | | } [INFO] [stdout] | |_- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this pattern will always match, so the `if let` is useless [INFO] [stdout] = help: consider replacing the `if let` with a `let` [INFO] [stdout] = note: this warning originates in the macro `impl_varuint` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: irrefutable `if let` pattern [INFO] [stdout] --> src/varuint.rs:416:20 [INFO] [stdout] | [INFO] [stdout] 416 | if let Ok(value) = value.try_into() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 450 | / impl_varuint! { [INFO] [stdout] 451 | | u8 [1 2 3 4 5 6 7 8], [INFO] [stdout] 452 | | u16 [9 10 11 12 13 14 15 16], [INFO] [stdout] 453 | | u32 [17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32], [INFO] [stdout] 454 | | u64 [33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64], [INFO] [stdout] 455 | | u128 [65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 10... [INFO] [stdout] 456 | | } [INFO] [stdout] | |_- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this pattern will always match, so the `if let` is useless [INFO] [stdout] = help: consider replacing the `if let` with a `let` [INFO] [stdout] = note: this warning originates in the macro `impl_varuint` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: irrefutable `if let` pattern [INFO] [stdout] --> src/varuint.rs:416:20 [INFO] [stdout] | [INFO] [stdout] 416 | if let Ok(value) = value.try_into() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 450 | / impl_varuint! { [INFO] [stdout] 451 | | u8 [1 2 3 4 5 6 7 8], [INFO] [stdout] 452 | | u16 [9 10 11 12 13 14 15 16], [INFO] [stdout] 453 | | u32 [17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32], [INFO] [stdout] 454 | | u64 [33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64], [INFO] [stdout] 455 | | u128 [65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 10... [INFO] [stdout] 456 | | } [INFO] [stdout] | |_- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this pattern will always match, so the `if let` is useless [INFO] [stdout] = help: consider replacing the `if let` with a `let` [INFO] [stdout] = note: this warning originates in the macro `impl_varuint` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: irrefutable `if let` pattern [INFO] [stdout] --> src/varuint.rs:416:20 [INFO] [stdout] | [INFO] [stdout] 416 | if let Ok(value) = value.try_into() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 450 | / impl_varuint! { [INFO] [stdout] 451 | | u8 [1 2 3 4 5 6 7 8], [INFO] [stdout] 452 | | u16 [9 10 11 12 13 14 15 16], [INFO] [stdout] 453 | | u32 [17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32], [INFO] [stdout] 454 | | u64 [33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64], [INFO] [stdout] 455 | | u128 [65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 10... [INFO] [stdout] 456 | | } [INFO] [stdout] | |_- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this pattern will always match, so the `if let` is useless [INFO] [stdout] = help: consider replacing the `if let` with a `let` [INFO] [stdout] = note: this warning originates in the macro `impl_varuint` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: irrefutable `if let` pattern [INFO] [stdout] --> src/varuint.rs:416:20 [INFO] [stdout] | [INFO] [stdout] 416 | if let Ok(value) = value.try_into() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 450 | / impl_varuint! { [INFO] [stdout] 451 | | u8 [1 2 3 4 5 6 7 8], [INFO] [stdout] 452 | | u16 [9 10 11 12 13 14 15 16], [INFO] [stdout] 453 | | u32 [17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32], [INFO] [stdout] 454 | | u64 [33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64], [INFO] [stdout] 455 | | u128 [65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 10... [INFO] [stdout] 456 | | } [INFO] [stdout] | |_- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this pattern will always match, so the `if let` is useless [INFO] [stdout] = help: consider replacing the `if let` with a `let` [INFO] [stdout] = note: this warning originates in the macro `impl_varuint` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: irrefutable `if let` pattern [INFO] [stdout] --> src/varuint.rs:416:20 [INFO] [stdout] | [INFO] [stdout] 416 | if let Ok(value) = value.try_into() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 450 | / impl_varuint! { [INFO] [stdout] 451 | | u8 [1 2 3 4 5 6 7 8], [INFO] [stdout] 452 | | u16 [9 10 11 12 13 14 15 16], [INFO] [stdout] 453 | | u32 [17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32], [INFO] [stdout] 454 | | u64 [33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64], [INFO] [stdout] 455 | | u128 [65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 10... [INFO] [stdout] 456 | | } [INFO] [stdout] | |_- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this pattern will always match, so the `if let` is useless [INFO] [stdout] = help: consider replacing the `if let` with a `let` [INFO] [stdout] = note: this warning originates in the macro `impl_varuint` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: irrefutable `if let` pattern [INFO] [stdout] --> src/varuint.rs:416:20 [INFO] [stdout] | [INFO] [stdout] 416 | if let Ok(value) = value.try_into() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 450 | / impl_varuint! { [INFO] [stdout] 451 | | u8 [1 2 3 4 5 6 7 8], [INFO] [stdout] 452 | | u16 [9 10 11 12 13 14 15 16], [INFO] [stdout] 453 | | u32 [17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32], [INFO] [stdout] 454 | | u64 [33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64], [INFO] [stdout] 455 | | u128 [65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 10... [INFO] [stdout] 456 | | } [INFO] [stdout] | |_- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this pattern will always match, so the `if let` is useless [INFO] [stdout] = help: consider replacing the `if let` with a `let` [INFO] [stdout] = note: this warning originates in the macro `impl_varuint` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: irrefutable `if let` pattern [INFO] [stdout] --> src/varuint.rs:416:20 [INFO] [stdout] | [INFO] [stdout] 416 | if let Ok(value) = value.try_into() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 450 | / impl_varuint! { [INFO] [stdout] 451 | | u8 [1 2 3 4 5 6 7 8], [INFO] [stdout] 452 | | u16 [9 10 11 12 13 14 15 16], [INFO] [stdout] 453 | | u32 [17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32], [INFO] [stdout] 454 | | u64 [33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64], [INFO] [stdout] 455 | | u128 [65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 10... [INFO] [stdout] 456 | | } [INFO] [stdout] | |_- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this pattern will always match, so the `if let` is useless [INFO] [stdout] = help: consider replacing the `if let` with a `let` [INFO] [stdout] = note: this warning originates in the macro `impl_varuint` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: irrefutable `if let` pattern [INFO] [stdout] --> src/varuint.rs:416:20 [INFO] [stdout] | [INFO] [stdout] 416 | if let Ok(value) = value.try_into() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 450 | / impl_varuint! { [INFO] [stdout] 451 | | u8 [1 2 3 4 5 6 7 8], [INFO] [stdout] 452 | | u16 [9 10 11 12 13 14 15 16], [INFO] [stdout] 453 | | u32 [17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32], [INFO] [stdout] 454 | | u64 [33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64], [INFO] [stdout] 455 | | u128 [65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 10... [INFO] [stdout] 456 | | } [INFO] [stdout] | |_- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this pattern will always match, so the `if let` is useless [INFO] [stdout] = help: consider replacing the `if let` with a `let` [INFO] [stdout] = note: this warning originates in the macro `impl_varuint` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: irrefutable `if let` pattern [INFO] [stdout] --> src/varuint.rs:416:20 [INFO] [stdout] | [INFO] [stdout] 416 | if let Ok(value) = value.try_into() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 450 | / impl_varuint! { [INFO] [stdout] 451 | | u8 [1 2 3 4 5 6 7 8], [INFO] [stdout] 452 | | u16 [9 10 11 12 13 14 15 16], [INFO] [stdout] 453 | | u32 [17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32], [INFO] [stdout] 454 | | u64 [33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64], [INFO] [stdout] 455 | | u128 [65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 10... [INFO] [stdout] 456 | | } [INFO] [stdout] | |_- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this pattern will always match, so the `if let` is useless [INFO] [stdout] = help: consider replacing the `if let` with a `let` [INFO] [stdout] = note: this warning originates in the macro `impl_varuint` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: irrefutable `if let` pattern [INFO] [stdout] --> src/varuint.rs:416:20 [INFO] [stdout] | [INFO] [stdout] 416 | if let Ok(value) = value.try_into() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 450 | / impl_varuint! { [INFO] [stdout] 451 | | u8 [1 2 3 4 5 6 7 8], [INFO] [stdout] 452 | | u16 [9 10 11 12 13 14 15 16], [INFO] [stdout] 453 | | u32 [17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32], [INFO] [stdout] 454 | | u64 [33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64], [INFO] [stdout] 455 | | u128 [65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 10... [INFO] [stdout] 456 | | } [INFO] [stdout] | |_- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this pattern will always match, so the `if let` is useless [INFO] [stdout] = help: consider replacing the `if let` with a `let` [INFO] [stdout] = note: this warning originates in the macro `impl_varuint` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: irrefutable `if let` pattern [INFO] [stdout] --> src/varuint.rs:416:20 [INFO] [stdout] | [INFO] [stdout] 416 | if let Ok(value) = value.try_into() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 450 | / impl_varuint! { [INFO] [stdout] 451 | | u8 [1 2 3 4 5 6 7 8], [INFO] [stdout] 452 | | u16 [9 10 11 12 13 14 15 16], [INFO] [stdout] 453 | | u32 [17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32], [INFO] [stdout] 454 | | u64 [33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64], [INFO] [stdout] 455 | | u128 [65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 10... [INFO] [stdout] 456 | | } [INFO] [stdout] | |_- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this pattern will always match, so the `if let` is useless [INFO] [stdout] = help: consider replacing the `if let` with a `let` [INFO] [stdout] = note: this warning originates in the macro `impl_varuint` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: irrefutable `if let` pattern [INFO] [stdout] --> src/varuint.rs:416:20 [INFO] [stdout] | [INFO] [stdout] 416 | if let Ok(value) = value.try_into() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 450 | / impl_varuint! { [INFO] [stdout] 451 | | u8 [1 2 3 4 5 6 7 8], [INFO] [stdout] 452 | | u16 [9 10 11 12 13 14 15 16], [INFO] [stdout] 453 | | u32 [17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32], [INFO] [stdout] 454 | | u64 [33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64], [INFO] [stdout] 455 | | u128 [65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 10... [INFO] [stdout] 456 | | } [INFO] [stdout] | |_- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this pattern will always match, so the `if let` is useless [INFO] [stdout] = help: consider replacing the `if let` with a `let` [INFO] [stdout] = note: this warning originates in the macro `impl_varuint` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: irrefutable `if let` pattern [INFO] [stdout] --> src/varuint.rs:416:20 [INFO] [stdout] | [INFO] [stdout] 416 | if let Ok(value) = value.try_into() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 450 | / impl_varuint! { [INFO] [stdout] 451 | | u8 [1 2 3 4 5 6 7 8], [INFO] [stdout] 452 | | u16 [9 10 11 12 13 14 15 16], [INFO] [stdout] 453 | | u32 [17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32], [INFO] [stdout] 454 | | u64 [33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64], [INFO] [stdout] 455 | | u128 [65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 10... [INFO] [stdout] 456 | | } [INFO] [stdout] | |_- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this pattern will always match, so the `if let` is useless [INFO] [stdout] = help: consider replacing the `if let` with a `let` [INFO] [stdout] = note: this warning originates in the macro `impl_varuint` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: irrefutable `if let` pattern [INFO] [stdout] --> src/varuint.rs:416:20 [INFO] [stdout] | [INFO] [stdout] 416 | if let Ok(value) = value.try_into() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 450 | / impl_varuint! { [INFO] [stdout] 451 | | u8 [1 2 3 4 5 6 7 8], [INFO] [stdout] 452 | | u16 [9 10 11 12 13 14 15 16], [INFO] [stdout] 453 | | u32 [17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32], [INFO] [stdout] 454 | | u64 [33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64], [INFO] [stdout] 455 | | u128 [65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 10... [INFO] [stdout] 456 | | } [INFO] [stdout] | |_- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this pattern will always match, so the `if let` is useless [INFO] [stdout] = help: consider replacing the `if let` with a `let` [INFO] [stdout] = note: this warning originates in the macro `impl_varuint` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: irrefutable `if let` pattern [INFO] [stdout] --> src/varuint.rs:416:20 [INFO] [stdout] | [INFO] [stdout] 416 | if let Ok(value) = value.try_into() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 450 | / impl_varuint! { [INFO] [stdout] 451 | | u8 [1 2 3 4 5 6 7 8], [INFO] [stdout] 452 | | u16 [9 10 11 12 13 14 15 16], [INFO] [stdout] 453 | | u32 [17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32], [INFO] [stdout] 454 | | u64 [33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64], [INFO] [stdout] 455 | | u128 [65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 10... [INFO] [stdout] 456 | | } [INFO] [stdout] | |_- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this pattern will always match, so the `if let` is useless [INFO] [stdout] = help: consider replacing the `if let` with a `let` [INFO] [stdout] = note: this warning originates in the macro `impl_varuint` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: irrefutable `if let` pattern [INFO] [stdout] --> src/varuint.rs:416:20 [INFO] [stdout] | [INFO] [stdout] 416 | if let Ok(value) = value.try_into() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 450 | / impl_varuint! { [INFO] [stdout] 451 | | u8 [1 2 3 4 5 6 7 8], [INFO] [stdout] 452 | | u16 [9 10 11 12 13 14 15 16], [INFO] [stdout] 453 | | u32 [17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32], [INFO] [stdout] 454 | | u64 [33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64], [INFO] [stdout] 455 | | u128 [65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 10... [INFO] [stdout] 456 | | } [INFO] [stdout] | |_- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this pattern will always match, so the `if let` is useless [INFO] [stdout] = help: consider replacing the `if let` with a `let` [INFO] [stdout] = note: this warning originates in the macro `impl_varuint` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: irrefutable `if let` pattern [INFO] [stdout] --> src/varuint.rs:416:20 [INFO] [stdout] | [INFO] [stdout] 416 | if let Ok(value) = value.try_into() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 450 | / impl_varuint! { [INFO] [stdout] 451 | | u8 [1 2 3 4 5 6 7 8], [INFO] [stdout] 452 | | u16 [9 10 11 12 13 14 15 16], [INFO] [stdout] 453 | | u32 [17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32], [INFO] [stdout] 454 | | u64 [33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64], [INFO] [stdout] 455 | | u128 [65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 10... [INFO] [stdout] 456 | | } [INFO] [stdout] | |_- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this pattern will always match, so the `if let` is useless [INFO] [stdout] = help: consider replacing the `if let` with a `let` [INFO] [stdout] = note: this warning originates in the macro `impl_varuint` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: irrefutable `if let` pattern [INFO] [stdout] --> src/varuint.rs:416:20 [INFO] [stdout] | [INFO] [stdout] 416 | if let Ok(value) = value.try_into() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 450 | / impl_varuint! { [INFO] [stdout] 451 | | u8 [1 2 3 4 5 6 7 8], [INFO] [stdout] 452 | | u16 [9 10 11 12 13 14 15 16], [INFO] [stdout] 453 | | u32 [17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32], [INFO] [stdout] 454 | | u64 [33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64], [INFO] [stdout] 455 | | u128 [65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 10... [INFO] [stdout] 456 | | } [INFO] [stdout] | |_- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this pattern will always match, so the `if let` is useless [INFO] [stdout] = help: consider replacing the `if let` with a `let` [INFO] [stdout] = note: this warning originates in the macro `impl_varuint` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: irrefutable `if let` pattern [INFO] [stdout] --> src/varuint.rs:416:20 [INFO] [stdout] | [INFO] [stdout] 416 | if let Ok(value) = value.try_into() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 450 | / impl_varuint! { [INFO] [stdout] 451 | | u8 [1 2 3 4 5 6 7 8], [INFO] [stdout] 452 | | u16 [9 10 11 12 13 14 15 16], [INFO] [stdout] 453 | | u32 [17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32], [INFO] [stdout] 454 | | u64 [33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64], [INFO] [stdout] 455 | | u128 [65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 10... [INFO] [stdout] 456 | | } [INFO] [stdout] | |_- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this pattern will always match, so the `if let` is useless [INFO] [stdout] = help: consider replacing the `if let` with a `let` [INFO] [stdout] = note: this warning originates in the macro `impl_varuint` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: irrefutable `if let` pattern [INFO] [stdout] --> src/varuint.rs:416:20 [INFO] [stdout] | [INFO] [stdout] 416 | if let Ok(value) = value.try_into() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 450 | / impl_varuint! { [INFO] [stdout] 451 | | u8 [1 2 3 4 5 6 7 8], [INFO] [stdout] 452 | | u16 [9 10 11 12 13 14 15 16], [INFO] [stdout] 453 | | u32 [17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32], [INFO] [stdout] 454 | | u64 [33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64], [INFO] [stdout] 455 | | u128 [65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 10... [INFO] [stdout] 456 | | } [INFO] [stdout] | |_- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this pattern will always match, so the `if let` is useless [INFO] [stdout] = help: consider replacing the `if let` with a `let` [INFO] [stdout] = note: this warning originates in the macro `impl_varuint` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: irrefutable `if let` pattern [INFO] [stdout] --> src/varuint.rs:416:20 [INFO] [stdout] | [INFO] [stdout] 416 | if let Ok(value) = value.try_into() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 450 | / impl_varuint! { [INFO] [stdout] 451 | | u8 [1 2 3 4 5 6 7 8], [INFO] [stdout] 452 | | u16 [9 10 11 12 13 14 15 16], [INFO] [stdout] 453 | | u32 [17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32], [INFO] [stdout] 454 | | u64 [33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64], [INFO] [stdout] 455 | | u128 [65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 10... [INFO] [stdout] 456 | | } [INFO] [stdout] | |_- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this pattern will always match, so the `if let` is useless [INFO] [stdout] = help: consider replacing the `if let` with a `let` [INFO] [stdout] = note: this warning originates in the macro `impl_varuint` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: irrefutable `if let` pattern [INFO] [stdout] --> src/varuint.rs:416:20 [INFO] [stdout] | [INFO] [stdout] 416 | if let Ok(value) = value.try_into() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 450 | / impl_varuint! { [INFO] [stdout] 451 | | u8 [1 2 3 4 5 6 7 8], [INFO] [stdout] 452 | | u16 [9 10 11 12 13 14 15 16], [INFO] [stdout] 453 | | u32 [17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32], [INFO] [stdout] 454 | | u64 [33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64], [INFO] [stdout] 455 | | u128 [65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 10... [INFO] [stdout] 456 | | } [INFO] [stdout] | |_- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this pattern will always match, so the `if let` is useless [INFO] [stdout] = help: consider replacing the `if let` with a `let` [INFO] [stdout] = note: this warning originates in the macro `impl_varuint` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: irrefutable `if let` pattern [INFO] [stdout] --> src/varuint.rs:416:20 [INFO] [stdout] | [INFO] [stdout] 416 | if let Ok(value) = value.try_into() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 450 | / impl_varuint! { [INFO] [stdout] 451 | | u8 [1 2 3 4 5 6 7 8], [INFO] [stdout] 452 | | u16 [9 10 11 12 13 14 15 16], [INFO] [stdout] 453 | | u32 [17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32], [INFO] [stdout] 454 | | u64 [33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64], [INFO] [stdout] 455 | | u128 [65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 10... [INFO] [stdout] 456 | | } [INFO] [stdout] | |_- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this pattern will always match, so the `if let` is useless [INFO] [stdout] = help: consider replacing the `if let` with a `let` [INFO] [stdout] = note: this warning originates in the macro `impl_varuint` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: irrefutable `if let` pattern [INFO] [stdout] --> src/varuint.rs:416:20 [INFO] [stdout] | [INFO] [stdout] 416 | if let Ok(value) = value.try_into() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 450 | / impl_varuint! { [INFO] [stdout] 451 | | u8 [1 2 3 4 5 6 7 8], [INFO] [stdout] 452 | | u16 [9 10 11 12 13 14 15 16], [INFO] [stdout] 453 | | u32 [17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32], [INFO] [stdout] 454 | | u64 [33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64], [INFO] [stdout] 455 | | u128 [65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 10... [INFO] [stdout] 456 | | } [INFO] [stdout] | |_- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this pattern will always match, so the `if let` is useless [INFO] [stdout] = help: consider replacing the `if let` with a `let` [INFO] [stdout] = note: this warning originates in the macro `impl_varuint` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: irrefutable `if let` pattern [INFO] [stdout] --> src/varuint.rs:416:20 [INFO] [stdout] | [INFO] [stdout] 416 | if let Ok(value) = value.try_into() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 450 | / impl_varuint! { [INFO] [stdout] 451 | | u8 [1 2 3 4 5 6 7 8], [INFO] [stdout] 452 | | u16 [9 10 11 12 13 14 15 16], [INFO] [stdout] 453 | | u32 [17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32], [INFO] [stdout] 454 | | u64 [33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64], [INFO] [stdout] 455 | | u128 [65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 10... [INFO] [stdout] 456 | | } [INFO] [stdout] | |_- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this pattern will always match, so the `if let` is useless [INFO] [stdout] = help: consider replacing the `if let` with a `let` [INFO] [stdout] = note: this warning originates in the macro `impl_varuint` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: irrefutable `if let` pattern [INFO] [stdout] --> src/varuint.rs:416:20 [INFO] [stdout] | [INFO] [stdout] 416 | if let Ok(value) = value.try_into() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 450 | / impl_varuint! { [INFO] [stdout] 451 | | u8 [1 2 3 4 5 6 7 8], [INFO] [stdout] 452 | | u16 [9 10 11 12 13 14 15 16], [INFO] [stdout] 453 | | u32 [17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32], [INFO] [stdout] 454 | | u64 [33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64], [INFO] [stdout] 455 | | u128 [65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 10... [INFO] [stdout] 456 | | } [INFO] [stdout] | |_- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this pattern will always match, so the `if let` is useless [INFO] [stdout] = help: consider replacing the `if let` with a `let` [INFO] [stdout] = note: this warning originates in the macro `impl_varuint` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: irrefutable `if let` pattern [INFO] [stdout] --> src/varuint.rs:416:20 [INFO] [stdout] | [INFO] [stdout] 416 | if let Ok(value) = value.try_into() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 450 | / impl_varuint! { [INFO] [stdout] 451 | | u8 [1 2 3 4 5 6 7 8], [INFO] [stdout] 452 | | u16 [9 10 11 12 13 14 15 16], [INFO] [stdout] 453 | | u32 [17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32], [INFO] [stdout] 454 | | u64 [33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64], [INFO] [stdout] 455 | | u128 [65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 10... [INFO] [stdout] 456 | | } [INFO] [stdout] | |_- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this pattern will always match, so the `if let` is useless [INFO] [stdout] = help: consider replacing the `if let` with a `let` [INFO] [stdout] = note: this warning originates in the macro `impl_varuint` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: irrefutable `if let` pattern [INFO] [stdout] --> src/varuint.rs:416:20 [INFO] [stdout] | [INFO] [stdout] 416 | if let Ok(value) = value.try_into() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 450 | / impl_varuint! { [INFO] [stdout] 451 | | u8 [1 2 3 4 5 6 7 8], [INFO] [stdout] 452 | | u16 [9 10 11 12 13 14 15 16], [INFO] [stdout] 453 | | u32 [17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32], [INFO] [stdout] 454 | | u64 [33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64], [INFO] [stdout] 455 | | u128 [65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 10... [INFO] [stdout] 456 | | } [INFO] [stdout] | |_- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this pattern will always match, so the `if let` is useless [INFO] [stdout] = help: consider replacing the `if let` with a `let` [INFO] [stdout] = note: this warning originates in the macro `impl_varuint` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: irrefutable `if let` pattern [INFO] [stdout] --> src/varuint.rs:416:20 [INFO] [stdout] | [INFO] [stdout] 416 | if let Ok(value) = value.try_into() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 450 | / impl_varuint! { [INFO] [stdout] 451 | | u8 [1 2 3 4 5 6 7 8], [INFO] [stdout] 452 | | u16 [9 10 11 12 13 14 15 16], [INFO] [stdout] 453 | | u32 [17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32], [INFO] [stdout] 454 | | u64 [33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64], [INFO] [stdout] 455 | | u128 [65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 10... [INFO] [stdout] 456 | | } [INFO] [stdout] | |_- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this pattern will always match, so the `if let` is useless [INFO] [stdout] = help: consider replacing the `if let` with a `let` [INFO] [stdout] = note: this warning originates in the macro `impl_varuint` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: irrefutable `if let` pattern [INFO] [stdout] --> src/varuint.rs:416:20 [INFO] [stdout] | [INFO] [stdout] 416 | if let Ok(value) = value.try_into() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 450 | / impl_varuint! { [INFO] [stdout] 451 | | u8 [1 2 3 4 5 6 7 8], [INFO] [stdout] 452 | | u16 [9 10 11 12 13 14 15 16], [INFO] [stdout] 453 | | u32 [17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32], [INFO] [stdout] 454 | | u64 [33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64], [INFO] [stdout] 455 | | u128 [65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 10... [INFO] [stdout] 456 | | } [INFO] [stdout] | |_- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this pattern will always match, so the `if let` is useless [INFO] [stdout] = help: consider replacing the `if let` with a `let` [INFO] [stdout] = note: this warning originates in the macro `impl_varuint` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: irrefutable `if let` pattern [INFO] [stdout] --> src/varuint.rs:416:20 [INFO] [stdout] | [INFO] [stdout] 416 | if let Ok(value) = value.try_into() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 450 | / impl_varuint! { [INFO] [stdout] 451 | | u8 [1 2 3 4 5 6 7 8], [INFO] [stdout] 452 | | u16 [9 10 11 12 13 14 15 16], [INFO] [stdout] 453 | | u32 [17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32], [INFO] [stdout] 454 | | u64 [33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64], [INFO] [stdout] 455 | | u128 [65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 10... [INFO] [stdout] 456 | | } [INFO] [stdout] | |_- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this pattern will always match, so the `if let` is useless [INFO] [stdout] = help: consider replacing the `if let` with a `let` [INFO] [stdout] = note: this warning originates in the macro `impl_varuint` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: irrefutable `if let` pattern [INFO] [stdout] --> src/varuint.rs:416:20 [INFO] [stdout] | [INFO] [stdout] 416 | if let Ok(value) = value.try_into() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 450 | / impl_varuint! { [INFO] [stdout] 451 | | u8 [1 2 3 4 5 6 7 8], [INFO] [stdout] 452 | | u16 [9 10 11 12 13 14 15 16], [INFO] [stdout] 453 | | u32 [17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32], [INFO] [stdout] 454 | | u64 [33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64], [INFO] [stdout] 455 | | u128 [65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 10... [INFO] [stdout] 456 | | } [INFO] [stdout] | |_- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this pattern will always match, so the `if let` is useless [INFO] [stdout] = help: consider replacing the `if let` with a `let` [INFO] [stdout] = note: this warning originates in the macro `impl_varuint` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: irrefutable `if let` pattern [INFO] [stdout] --> src/varuint.rs:416:20 [INFO] [stdout] | [INFO] [stdout] 416 | if let Ok(value) = value.try_into() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 450 | / impl_varuint! { [INFO] [stdout] 451 | | u8 [1 2 3 4 5 6 7 8], [INFO] [stdout] 452 | | u16 [9 10 11 12 13 14 15 16], [INFO] [stdout] 453 | | u32 [17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32], [INFO] [stdout] 454 | | u64 [33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64], [INFO] [stdout] 455 | | u128 [65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 10... [INFO] [stdout] 456 | | } [INFO] [stdout] | |_- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this pattern will always match, so the `if let` is useless [INFO] [stdout] = help: consider replacing the `if let` with a `let` [INFO] [stdout] = note: this warning originates in the macro `impl_varuint` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: irrefutable `if let` pattern [INFO] [stdout] --> src/varuint.rs:416:20 [INFO] [stdout] | [INFO] [stdout] 416 | if let Ok(value) = value.try_into() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 450 | / impl_varuint! { [INFO] [stdout] 451 | | u8 [1 2 3 4 5 6 7 8], [INFO] [stdout] 452 | | u16 [9 10 11 12 13 14 15 16], [INFO] [stdout] 453 | | u32 [17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32], [INFO] [stdout] 454 | | u64 [33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64], [INFO] [stdout] 455 | | u128 [65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 10... [INFO] [stdout] 456 | | } [INFO] [stdout] | |_- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this pattern will always match, so the `if let` is useless [INFO] [stdout] = help: consider replacing the `if let` with a `let` [INFO] [stdout] = note: this warning originates in the macro `impl_varuint` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: irrefutable `if let` pattern [INFO] [stdout] --> src/varuint.rs:416:20 [INFO] [stdout] | [INFO] [stdout] 416 | if let Ok(value) = value.try_into() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 450 | / impl_varuint! { [INFO] [stdout] 451 | | u8 [1 2 3 4 5 6 7 8], [INFO] [stdout] 452 | | u16 [9 10 11 12 13 14 15 16], [INFO] [stdout] 453 | | u32 [17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32], [INFO] [stdout] 454 | | u64 [33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64], [INFO] [stdout] 455 | | u128 [65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 10... [INFO] [stdout] 456 | | } [INFO] [stdout] | |_- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this pattern will always match, so the `if let` is useless [INFO] [stdout] = help: consider replacing the `if let` with a `let` [INFO] [stdout] = note: this warning originates in the macro `impl_varuint` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: irrefutable `if let` pattern [INFO] [stdout] --> src/varuint.rs:416:20 [INFO] [stdout] | [INFO] [stdout] 416 | if let Ok(value) = value.try_into() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 450 | / impl_varuint! { [INFO] [stdout] 451 | | u8 [1 2 3 4 5 6 7 8], [INFO] [stdout] 452 | | u16 [9 10 11 12 13 14 15 16], [INFO] [stdout] 453 | | u32 [17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32], [INFO] [stdout] 454 | | u64 [33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64], [INFO] [stdout] 455 | | u128 [65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 10... [INFO] [stdout] 456 | | } [INFO] [stdout] | |_- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this pattern will always match, so the `if let` is useless [INFO] [stdout] = help: consider replacing the `if let` with a `let` [INFO] [stdout] = note: this warning originates in the macro `impl_varuint` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: irrefutable `if let` pattern [INFO] [stdout] --> src/varuint.rs:416:20 [INFO] [stdout] | [INFO] [stdout] 416 | if let Ok(value) = value.try_into() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 450 | / impl_varuint! { [INFO] [stdout] 451 | | u8 [1 2 3 4 5 6 7 8], [INFO] [stdout] 452 | | u16 [9 10 11 12 13 14 15 16], [INFO] [stdout] 453 | | u32 [17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32], [INFO] [stdout] 454 | | u64 [33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64], [INFO] [stdout] 455 | | u128 [65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 10... [INFO] [stdout] 456 | | } [INFO] [stdout] | |_- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this pattern will always match, so the `if let` is useless [INFO] [stdout] = help: consider replacing the `if let` with a `let` [INFO] [stdout] = note: this warning originates in the macro `impl_varuint` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: irrefutable `if let` pattern [INFO] [stdout] --> src/varuint.rs:416:20 [INFO] [stdout] | [INFO] [stdout] 416 | if let Ok(value) = value.try_into() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 450 | / impl_varuint! { [INFO] [stdout] 451 | | u8 [1 2 3 4 5 6 7 8], [INFO] [stdout] 452 | | u16 [9 10 11 12 13 14 15 16], [INFO] [stdout] 453 | | u32 [17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32], [INFO] [stdout] 454 | | u64 [33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64], [INFO] [stdout] 455 | | u128 [65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 10... [INFO] [stdout] 456 | | } [INFO] [stdout] | |_- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this pattern will always match, so the `if let` is useless [INFO] [stdout] = help: consider replacing the `if let` with a `let` [INFO] [stdout] = note: this warning originates in the macro `impl_varuint` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: irrefutable `if let` pattern [INFO] [stdout] --> src/varuint.rs:416:20 [INFO] [stdout] | [INFO] [stdout] 416 | if let Ok(value) = value.try_into() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 450 | / impl_varuint! { [INFO] [stdout] 451 | | u8 [1 2 3 4 5 6 7 8], [INFO] [stdout] 452 | | u16 [9 10 11 12 13 14 15 16], [INFO] [stdout] 453 | | u32 [17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32], [INFO] [stdout] 454 | | u64 [33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64], [INFO] [stdout] 455 | | u128 [65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 10... [INFO] [stdout] 456 | | } [INFO] [stdout] | |_- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this pattern will always match, so the `if let` is useless [INFO] [stdout] = help: consider replacing the `if let` with a `let` [INFO] [stdout] = note: this warning originates in the macro `impl_varuint` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: irrefutable `if let` pattern [INFO] [stdout] --> src/varuint.rs:416:20 [INFO] [stdout] | [INFO] [stdout] 416 | if let Ok(value) = value.try_into() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 450 | / impl_varuint! { [INFO] [stdout] 451 | | u8 [1 2 3 4 5 6 7 8], [INFO] [stdout] 452 | | u16 [9 10 11 12 13 14 15 16], [INFO] [stdout] 453 | | u32 [17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32], [INFO] [stdout] 454 | | u64 [33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64], [INFO] [stdout] 455 | | u128 [65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 10... [INFO] [stdout] 456 | | } [INFO] [stdout] | |_- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this pattern will always match, so the `if let` is useless [INFO] [stdout] = help: consider replacing the `if let` with a `let` [INFO] [stdout] = note: this warning originates in the macro `impl_varuint` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: irrefutable `if let` pattern [INFO] [stdout] --> src/varuint.rs:416:20 [INFO] [stdout] | [INFO] [stdout] 416 | if let Ok(value) = value.try_into() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 450 | / impl_varuint! { [INFO] [stdout] 451 | | u8 [1 2 3 4 5 6 7 8], [INFO] [stdout] 452 | | u16 [9 10 11 12 13 14 15 16], [INFO] [stdout] 453 | | u32 [17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32], [INFO] [stdout] 454 | | u64 [33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64], [INFO] [stdout] 455 | | u128 [65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 10... [INFO] [stdout] 456 | | } [INFO] [stdout] | |_- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this pattern will always match, so the `if let` is useless [INFO] [stdout] = help: consider replacing the `if let` with a `let` [INFO] [stdout] = note: this warning originates in the macro `impl_varuint` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: irrefutable `if let` pattern [INFO] [stdout] --> src/varuint.rs:416:20 [INFO] [stdout] | [INFO] [stdout] 416 | if let Ok(value) = value.try_into() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 450 | / impl_varuint! { [INFO] [stdout] 451 | | u8 [1 2 3 4 5 6 7 8], [INFO] [stdout] 452 | | u16 [9 10 11 12 13 14 15 16], [INFO] [stdout] 453 | | u32 [17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32], [INFO] [stdout] 454 | | u64 [33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64], [INFO] [stdout] 455 | | u128 [65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 10... [INFO] [stdout] 456 | | } [INFO] [stdout] | |_- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this pattern will always match, so the `if let` is useless [INFO] [stdout] = help: consider replacing the `if let` with a `let` [INFO] [stdout] = note: this warning originates in the macro `impl_varuint` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: irrefutable `if let` pattern [INFO] [stdout] --> src/varuint.rs:416:20 [INFO] [stdout] | [INFO] [stdout] 416 | if let Ok(value) = value.try_into() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 450 | / impl_varuint! { [INFO] [stdout] 451 | | u8 [1 2 3 4 5 6 7 8], [INFO] [stdout] 452 | | u16 [9 10 11 12 13 14 15 16], [INFO] [stdout] 453 | | u32 [17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32], [INFO] [stdout] 454 | | u64 [33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64], [INFO] [stdout] 455 | | u128 [65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 10... [INFO] [stdout] 456 | | } [INFO] [stdout] | |_- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this pattern will always match, so the `if let` is useless [INFO] [stdout] = help: consider replacing the `if let` with a `let` [INFO] [stdout] = note: this warning originates in the macro `impl_varuint` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: irrefutable `if let` pattern [INFO] [stdout] --> src/varuint.rs:416:20 [INFO] [stdout] | [INFO] [stdout] 416 | if let Ok(value) = value.try_into() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 450 | / impl_varuint! { [INFO] [stdout] 451 | | u8 [1 2 3 4 5 6 7 8], [INFO] [stdout] 452 | | u16 [9 10 11 12 13 14 15 16], [INFO] [stdout] 453 | | u32 [17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32], [INFO] [stdout] 454 | | u64 [33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64], [INFO] [stdout] 455 | | u128 [65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 10... [INFO] [stdout] 456 | | } [INFO] [stdout] | |_- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this pattern will always match, so the `if let` is useless [INFO] [stdout] = help: consider replacing the `if let` with a `let` [INFO] [stdout] = note: this warning originates in the macro `impl_varuint` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: irrefutable `if let` pattern [INFO] [stdout] --> src/varuint.rs:416:20 [INFO] [stdout] | [INFO] [stdout] 416 | if let Ok(value) = value.try_into() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 450 | / impl_varuint! { [INFO] [stdout] 451 | | u8 [1 2 3 4 5 6 7 8], [INFO] [stdout] 452 | | u16 [9 10 11 12 13 14 15 16], [INFO] [stdout] 453 | | u32 [17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32], [INFO] [stdout] 454 | | u64 [33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64], [INFO] [stdout] 455 | | u128 [65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 10... [INFO] [stdout] 456 | | } [INFO] [stdout] | |_- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this pattern will always match, so the `if let` is useless [INFO] [stdout] = help: consider replacing the `if let` with a `let` [INFO] [stdout] = note: this warning originates in the macro `impl_varuint` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: irrefutable `if let` pattern [INFO] [stdout] --> src/varuint.rs:416:20 [INFO] [stdout] | [INFO] [stdout] 416 | if let Ok(value) = value.try_into() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 450 | / impl_varuint! { [INFO] [stdout] 451 | | u8 [1 2 3 4 5 6 7 8], [INFO] [stdout] 452 | | u16 [9 10 11 12 13 14 15 16], [INFO] [stdout] 453 | | u32 [17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32], [INFO] [stdout] 454 | | u64 [33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64], [INFO] [stdout] 455 | | u128 [65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 10... [INFO] [stdout] 456 | | } [INFO] [stdout] | |_- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this pattern will always match, so the `if let` is useless [INFO] [stdout] = help: consider replacing the `if let` with a `let` [INFO] [stdout] = note: this warning originates in the macro `impl_varuint` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: irrefutable `if let` pattern [INFO] [stdout] --> src/varuint.rs:416:20 [INFO] [stdout] | [INFO] [stdout] 416 | if let Ok(value) = value.try_into() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 450 | / impl_varuint! { [INFO] [stdout] 451 | | u8 [1 2 3 4 5 6 7 8], [INFO] [stdout] 452 | | u16 [9 10 11 12 13 14 15 16], [INFO] [stdout] 453 | | u32 [17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32], [INFO] [stdout] 454 | | u64 [33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64], [INFO] [stdout] 455 | | u128 [65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 10... [INFO] [stdout] 456 | | } [INFO] [stdout] | |_- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this pattern will always match, so the `if let` is useless [INFO] [stdout] = help: consider replacing the `if let` with a `let` [INFO] [stdout] = note: this warning originates in the macro `impl_varuint` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: irrefutable `if let` pattern [INFO] [stdout] --> src/varuint.rs:416:20 [INFO] [stdout] | [INFO] [stdout] 416 | if let Ok(value) = value.try_into() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 450 | / impl_varuint! { [INFO] [stdout] 451 | | u8 [1 2 3 4 5 6 7 8], [INFO] [stdout] 452 | | u16 [9 10 11 12 13 14 15 16], [INFO] [stdout] 453 | | u32 [17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32], [INFO] [stdout] 454 | | u64 [33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64], [INFO] [stdout] 455 | | u128 [65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 10... [INFO] [stdout] 456 | | } [INFO] [stdout] | |_- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this pattern will always match, so the `if let` is useless [INFO] [stdout] = help: consider replacing the `if let` with a `let` [INFO] [stdout] = note: this warning originates in the macro `impl_varuint` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: irrefutable `if let` pattern [INFO] [stdout] --> src/varuint.rs:416:20 [INFO] [stdout] | [INFO] [stdout] 416 | if let Ok(value) = value.try_into() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 450 | / impl_varuint! { [INFO] [stdout] 451 | | u8 [1 2 3 4 5 6 7 8], [INFO] [stdout] 452 | | u16 [9 10 11 12 13 14 15 16], [INFO] [stdout] 453 | | u32 [17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32], [INFO] [stdout] 454 | | u64 [33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64], [INFO] [stdout] 455 | | u128 [65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 10... [INFO] [stdout] 456 | | } [INFO] [stdout] | |_- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this pattern will always match, so the `if let` is useless [INFO] [stdout] = help: consider replacing the `if let` with a `let` [INFO] [stdout] = note: this warning originates in the macro `impl_varuint` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: irrefutable `if let` pattern [INFO] [stdout] --> src/varuint.rs:416:20 [INFO] [stdout] | [INFO] [stdout] 416 | if let Ok(value) = value.try_into() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 450 | / impl_varuint! { [INFO] [stdout] 451 | | u8 [1 2 3 4 5 6 7 8], [INFO] [stdout] 452 | | u16 [9 10 11 12 13 14 15 16], [INFO] [stdout] 453 | | u32 [17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32], [INFO] [stdout] 454 | | u64 [33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64], [INFO] [stdout] 455 | | u128 [65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 10... [INFO] [stdout] 456 | | } [INFO] [stdout] | |_- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this pattern will always match, so the `if let` is useless [INFO] [stdout] = help: consider replacing the `if let` with a `let` [INFO] [stdout] = note: this warning originates in the macro `impl_varuint` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: irrefutable `if let` pattern [INFO] [stdout] --> src/varuint.rs:416:20 [INFO] [stdout] | [INFO] [stdout] 416 | if let Ok(value) = value.try_into() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 450 | / impl_varuint! { [INFO] [stdout] 451 | | u8 [1 2 3 4 5 6 7 8], [INFO] [stdout] 452 | | u16 [9 10 11 12 13 14 15 16], [INFO] [stdout] 453 | | u32 [17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32], [INFO] [stdout] 454 | | u64 [33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64], [INFO] [stdout] 455 | | u128 [65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 10... [INFO] [stdout] 456 | | } [INFO] [stdout] | |_- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this pattern will always match, so the `if let` is useless [INFO] [stdout] = help: consider replacing the `if let` with a `let` [INFO] [stdout] = note: this warning originates in the macro `impl_varuint` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: irrefutable `if let` pattern [INFO] [stdout] --> src/varuint.rs:416:20 [INFO] [stdout] | [INFO] [stdout] 416 | if let Ok(value) = value.try_into() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 450 | / impl_varuint! { [INFO] [stdout] 451 | | u8 [1 2 3 4 5 6 7 8], [INFO] [stdout] 452 | | u16 [9 10 11 12 13 14 15 16], [INFO] [stdout] 453 | | u32 [17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32], [INFO] [stdout] 454 | | u64 [33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64], [INFO] [stdout] 455 | | u128 [65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 10... [INFO] [stdout] 456 | | } [INFO] [stdout] | |_- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this pattern will always match, so the `if let` is useless [INFO] [stdout] = help: consider replacing the `if let` with a `let` [INFO] [stdout] = note: this warning originates in the macro `impl_varuint` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: irrefutable `if let` pattern [INFO] [stdout] --> src/varuint.rs:416:20 [INFO] [stdout] | [INFO] [stdout] 416 | if let Ok(value) = value.try_into() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 450 | / impl_varuint! { [INFO] [stdout] 451 | | u8 [1 2 3 4 5 6 7 8], [INFO] [stdout] 452 | | u16 [9 10 11 12 13 14 15 16], [INFO] [stdout] 453 | | u32 [17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32], [INFO] [stdout] 454 | | u64 [33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64], [INFO] [stdout] 455 | | u128 [65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 10... [INFO] [stdout] 456 | | } [INFO] [stdout] | |_- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this pattern will always match, so the `if let` is useless [INFO] [stdout] = help: consider replacing the `if let` with a `let` [INFO] [stdout] = note: this warning originates in the macro `impl_varuint` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: irrefutable `if let` pattern [INFO] [stdout] --> src/varuint.rs:416:20 [INFO] [stdout] | [INFO] [stdout] 416 | if let Ok(value) = value.try_into() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 450 | / impl_varuint! { [INFO] [stdout] 451 | | u8 [1 2 3 4 5 6 7 8], [INFO] [stdout] 452 | | u16 [9 10 11 12 13 14 15 16], [INFO] [stdout] 453 | | u32 [17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32], [INFO] [stdout] 454 | | u64 [33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64], [INFO] [stdout] 455 | | u128 [65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 10... [INFO] [stdout] 456 | | } [INFO] [stdout] | |_- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this pattern will always match, so the `if let` is useless [INFO] [stdout] = help: consider replacing the `if let` with a `let` [INFO] [stdout] = note: this warning originates in the macro `impl_varuint` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: irrefutable `if let` pattern [INFO] [stdout] --> src/varuint.rs:416:20 [INFO] [stdout] | [INFO] [stdout] 416 | if let Ok(value) = value.try_into() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 450 | / impl_varuint! { [INFO] [stdout] 451 | | u8 [1 2 3 4 5 6 7 8], [INFO] [stdout] 452 | | u16 [9 10 11 12 13 14 15 16], [INFO] [stdout] 453 | | u32 [17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32], [INFO] [stdout] 454 | | u64 [33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64], [INFO] [stdout] 455 | | u128 [65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 10... [INFO] [stdout] 456 | | } [INFO] [stdout] | |_- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this pattern will always match, so the `if let` is useless [INFO] [stdout] = help: consider replacing the `if let` with a `let` [INFO] [stdout] = note: this warning originates in the macro `impl_varuint` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: irrefutable `if let` pattern [INFO] [stdout] --> src/varuint.rs:416:20 [INFO] [stdout] | [INFO] [stdout] 416 | if let Ok(value) = value.try_into() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 450 | / impl_varuint! { [INFO] [stdout] 451 | | u8 [1 2 3 4 5 6 7 8], [INFO] [stdout] 452 | | u16 [9 10 11 12 13 14 15 16], [INFO] [stdout] 453 | | u32 [17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32], [INFO] [stdout] 454 | | u64 [33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64], [INFO] [stdout] 455 | | u128 [65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 10... [INFO] [stdout] 456 | | } [INFO] [stdout] | |_- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this pattern will always match, so the `if let` is useless [INFO] [stdout] = help: consider replacing the `if let` with a `let` [INFO] [stdout] = note: this warning originates in the macro `impl_varuint` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: irrefutable `if let` pattern [INFO] [stdout] --> src/varuint.rs:416:20 [INFO] [stdout] | [INFO] [stdout] 416 | if let Ok(value) = value.try_into() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 450 | / impl_varuint! { [INFO] [stdout] 451 | | u8 [1 2 3 4 5 6 7 8], [INFO] [stdout] 452 | | u16 [9 10 11 12 13 14 15 16], [INFO] [stdout] 453 | | u32 [17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32], [INFO] [stdout] 454 | | u64 [33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64], [INFO] [stdout] 455 | | u128 [65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 10... [INFO] [stdout] 456 | | } [INFO] [stdout] | |_- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this pattern will always match, so the `if let` is useless [INFO] [stdout] = help: consider replacing the `if let` with a `let` [INFO] [stdout] = note: this warning originates in the macro `impl_varuint` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: irrefutable `if let` pattern [INFO] [stdout] --> src/varuint.rs:416:20 [INFO] [stdout] | [INFO] [stdout] 416 | if let Ok(value) = value.try_into() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 450 | / impl_varuint! { [INFO] [stdout] 451 | | u8 [1 2 3 4 5 6 7 8], [INFO] [stdout] 452 | | u16 [9 10 11 12 13 14 15 16], [INFO] [stdout] 453 | | u32 [17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32], [INFO] [stdout] 454 | | u64 [33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64], [INFO] [stdout] 455 | | u128 [65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 10... [INFO] [stdout] 456 | | } [INFO] [stdout] | |_- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this pattern will always match, so the `if let` is useless [INFO] [stdout] = help: consider replacing the `if let` with a `let` [INFO] [stdout] = note: this warning originates in the macro `impl_varuint` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: irrefutable `if let` pattern [INFO] [stdout] --> src/varuint.rs:416:20 [INFO] [stdout] | [INFO] [stdout] 416 | if let Ok(value) = value.try_into() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 450 | / impl_varuint! { [INFO] [stdout] 451 | | u8 [1 2 3 4 5 6 7 8], [INFO] [stdout] 452 | | u16 [9 10 11 12 13 14 15 16], [INFO] [stdout] 453 | | u32 [17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32], [INFO] [stdout] 454 | | u64 [33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64], [INFO] [stdout] 455 | | u128 [65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 10... [INFO] [stdout] 456 | | } [INFO] [stdout] | |_- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this pattern will always match, so the `if let` is useless [INFO] [stdout] = help: consider replacing the `if let` with a `let` [INFO] [stdout] = note: this warning originates in the macro `impl_varuint` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: irrefutable `if let` pattern [INFO] [stdout] --> src/varuint.rs:416:20 [INFO] [stdout] | [INFO] [stdout] 416 | if let Ok(value) = value.try_into() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 450 | / impl_varuint! { [INFO] [stdout] 451 | | u8 [1 2 3 4 5 6 7 8], [INFO] [stdout] 452 | | u16 [9 10 11 12 13 14 15 16], [INFO] [stdout] 453 | | u32 [17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32], [INFO] [stdout] 454 | | u64 [33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64], [INFO] [stdout] 455 | | u128 [65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 10... [INFO] [stdout] 456 | | } [INFO] [stdout] | |_- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this pattern will always match, so the `if let` is useless [INFO] [stdout] = help: consider replacing the `if let` with a `let` [INFO] [stdout] = note: this warning originates in the macro `impl_varuint` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: irrefutable `if let` pattern [INFO] [stdout] --> src/varuint.rs:416:20 [INFO] [stdout] | [INFO] [stdout] 416 | if let Ok(value) = value.try_into() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 450 | / impl_varuint! { [INFO] [stdout] 451 | | u8 [1 2 3 4 5 6 7 8], [INFO] [stdout] 452 | | u16 [9 10 11 12 13 14 15 16], [INFO] [stdout] 453 | | u32 [17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32], [INFO] [stdout] 454 | | u64 [33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64], [INFO] [stdout] 455 | | u128 [65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 10... [INFO] [stdout] 456 | | } [INFO] [stdout] | |_- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this pattern will always match, so the `if let` is useless [INFO] [stdout] = help: consider replacing the `if let` with a `let` [INFO] [stdout] = note: this warning originates in the macro `impl_varuint` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: irrefutable `if let` pattern [INFO] [stdout] --> src/varuint.rs:416:20 [INFO] [stdout] | [INFO] [stdout] 416 | if let Ok(value) = value.try_into() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 450 | / impl_varuint! { [INFO] [stdout] 451 | | u8 [1 2 3 4 5 6 7 8], [INFO] [stdout] 452 | | u16 [9 10 11 12 13 14 15 16], [INFO] [stdout] 453 | | u32 [17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32], [INFO] [stdout] 454 | | u64 [33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64], [INFO] [stdout] 455 | | u128 [65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 10... [INFO] [stdout] 456 | | } [INFO] [stdout] | |_- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this pattern will always match, so the `if let` is useless [INFO] [stdout] = help: consider replacing the `if let` with a `let` [INFO] [stdout] = note: this warning originates in the macro `impl_varuint` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stdout] warning: irrefutable `if let` pattern [INFO] [stdout] --> src/varuint.rs:416:20 [INFO] [stdout] | [INFO] [stdout] 416 | if let Ok(value) = value.try_into() { [INFO] [stdout] | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ [INFO] [stdout] ... [INFO] [stdout] 450 | / impl_varuint! { [INFO] [stdout] 451 | | u8 [1 2 3 4 5 6 7 8], [INFO] [stdout] 452 | | u16 [9 10 11 12 13 14 15 16], [INFO] [stdout] 453 | | u32 [17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32], [INFO] [stdout] 454 | | u64 [33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64], [INFO] [stdout] 455 | | u128 [65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 10... [INFO] [stdout] 456 | | } [INFO] [stdout] | |_- in this macro invocation [INFO] [stdout] | [INFO] [stdout] = note: this pattern will always match, so the `if let` is useless [INFO] [stdout] = help: consider replacing the `if let` with a `let` [INFO] [stdout] = note: this warning originates in the macro `impl_varuint` (in Nightly builds, run with -Z macro-backtrace for more info) [INFO] [stdout] [INFO] [stdout] [INFO] [stderr] error: could not compile `varint` (lib); 1 warning emitted [INFO] [stderr] [INFO] [stderr] Caused by: [INFO] [stderr] No space left on device (os error 28) [INFO] [stderr] [INFO] [stderr] Caused by: [INFO] [stderr] failed to parse process output: `/opt/rustwide/rustup-home/toolchains/b32fc44666c052e7cf07ab471bfb6f9ec571902f/bin/rustc --crate-name varint --edition=2021 src/lib.rs --error-format=json --json=diagnostic-rendered-ansi,artifacts,future-incompat --crate-type lib --emit=dep-info,metadata -C embed-bitcode=no -C debuginfo=2 --check-cfg 'cfg(docsrs,test)' --check-cfg 'cfg(feature, values())' -C metadata=69b281b9f4d8be03 -C extra-filename=-94d617032c343ccd --out-dir /opt/rustwide/target/debug/deps -L dependency=/opt/rustwide/target/debug/deps --cap-lints=forbid` (exit status: 1) [INFO] [stderr] warning: build failed, waiting for other jobs to finish... [INFO] [stderr] error: could not compile `varint` (lib test); 69 warnings emitted [INFO] [stderr] [INFO] [stderr] Caused by: [INFO] [stderr] No space left on device (os error 28) [INFO] [stderr] [INFO] [stderr] Caused by: [INFO] [stderr] failed to parse process output: `/opt/rustwide/rustup-home/toolchains/b32fc44666c052e7cf07ab471bfb6f9ec571902f/bin/rustc --crate-name varint --edition=2021 src/lib.rs --error-format=json --json=diagnostic-rendered-ansi,artifacts,future-incompat --emit=dep-info,metadata -C embed-bitcode=no -C debuginfo=2 --test --check-cfg 'cfg(docsrs,test)' --check-cfg 'cfg(feature, values())' -C metadata=6ba506b310da6c95 -C extra-filename=-37dd27bf6b8c4860 --out-dir /opt/rustwide/target/debug/deps -L dependency=/opt/rustwide/target/debug/deps --cap-lints=forbid` (exit status: 0) [INFO] running `Command { std: "docker" "inspect" "02594318c546dbe68da2f56d28e4b7c9a5add6229c6449168a528ea6e6df2788", kill_on_drop: false }` [INFO] running `Command { std: "docker" "rm" "-f" "02594318c546dbe68da2f56d28e4b7c9a5add6229c6449168a528ea6e6df2788", kill_on_drop: false }` [INFO] [stdout] 02594318c546dbe68da2f56d28e4b7c9a5add6229c6449168a528ea6e6df2788