[INFO] cloning repository https://github.com/kxxt/ptrace-syscalls
[INFO] running `Command { std: "git" "-c" "credential.helper=" "-c" "credential.helper=/workspace/cargo-home/bin/git-credential-null" "clone" "--bare" "https://github.com/kxxt/ptrace-syscalls" "/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2Fkxxt%2Fptrace-syscalls", kill_on_drop: false }`
[INFO] [stderr] Cloning into bare repository '/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2Fkxxt%2Fptrace-syscalls'...
[INFO] running `Command { std: "git" "rev-parse" "HEAD", kill_on_drop: false }`
[INFO] [stdout] 9d64652dcddfa5d46bb065d3d01243ae0688d73c
[INFO] checking kxxt/ptrace-syscalls against a5689b034ad287112f709693384a37f1377eb9cc for pr-129249-3
[INFO] running `Command { std: "git" "clone" "/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2Fkxxt%2Fptrace-syscalls" "/workspace/builds/worker-0-tc2/source", kill_on_drop: false }`
[INFO] [stderr] Cloning into '/workspace/builds/worker-0-tc2/source'...
[INFO] [stderr] done.
[INFO] started tweaking git repo https://github.com/kxxt/ptrace-syscalls
[INFO] finished tweaking git repo https://github.com/kxxt/ptrace-syscalls
[INFO] tweaked toml for git repo https://github.com/kxxt/ptrace-syscalls written to /workspace/builds/worker-0-tc2/source/Cargo.toml
[INFO] validating manifest of git repo https://github.com/kxxt/ptrace-syscalls 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/kxxt/ptrace-syscalls already has a lockfile, it will not be regenerated
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "fetch" "--manifest-path" "Cargo.toml", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-0-tc2/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-0-tc2/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/cargo-home:/opt/rustwide/cargo-home:ro,Z" "-v" "/var/lib/crater-agent-workspace/rustup-home:/opt/rustwide/rustup-home:ro,Z" "-m" "1610612736" "--network" "none" "ghcr.io/rust-lang/crates-build-env/linux@sha256:77db811e55d90add9212f6832c23229e3de5f1c1f9905e8cb07319ea15df73ac" "sleep" "infinity", kill_on_drop: false }`
[INFO] [stdout] 805444b328cd7735e6182cf170aaa2ea0a5063d5bd3ab7a6042839bfd4fcbe7a
[INFO] running `Command { std: "docker" "start" "805444b328cd7735e6182cf170aaa2ea0a5063d5bd3ab7a6042839bfd4fcbe7a", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "805444b328cd7735e6182cf170aaa2ea0a5063d5bd3ab7a6042839bfd4fcbe7a", 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" "805444b328cd7735e6182cf170aaa2ea0a5063d5bd3ab7a6042839bfd4fcbe7a" "/opt/rustwide/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "805444b328cd7735e6182cf170aaa2ea0a5063d5bd3ab7a6042839bfd4fcbe7a", 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" "805444b328cd7735e6182cf170aaa2ea0a5063d5bd3ab7a6042839bfd4fcbe7a" "/opt/rustwide/cargo-home/bin/cargo" "+a5689b034ad287112f709693384a37f1377eb9cc" "check" "--frozen" "--all" "--all-targets" "--message-format=json", kill_on_drop: false }`
[INFO] [stderr]    Compiling hashbrown v0.15.5
[INFO] [stderr]    Compiling libc v0.2.175
[INFO] [stderr]    Compiling winnow v0.7.13
[INFO] [stderr]    Compiling proc-macro2 v1.0.101
[INFO] [stderr]    Compiling erasable v1.3.0
[INFO] [stderr]    Compiling slice-dst v1.6.0
[INFO] [stderr]     Checking itertools v0.13.0
[INFO] [stderr]    Compiling nix v0.29.0
[INFO] [stderr]     Checking kxxt-owo-colors v4.0.0
[INFO] [stderr]     Checking unicode-ident v1.0.18
[INFO] [stderr]     Checking equivalent v1.0.2
[INFO] [stderr]     Checking toml_datetime v0.6.11
[INFO] [stderr]     Checking unicode-segmentation v1.12.0
[INFO] [stderr]    Compiling indexmap v2.11.0
[INFO] [stderr]     Checking convert_case v0.6.0
[INFO] [stderr]     Checking quote v1.0.40
[INFO] [stderr]    Compiling syn v2.0.106
[INFO] [stderr]    Compiling toml_edit v0.22.27
[INFO] [stderr]    Compiling enumflags2_derive v0.7.12
[INFO] [stderr]     Checking proc-macro-crate v3.3.0
[INFO] [stderr]     Checking ptrace-syscalls-macros v0.0.0-experimental.3 (/opt/rustwide/workdir/ptrace-syscalls-macros)
[INFO] [stderr]     Checking enumflags2 v0.7.12
[INFO] [stderr]     Checking ptrace-syscalls v0.0.0-experimental.3 (/opt/rustwide/workdir)
[INFO] [stdout] warning: function `read_lossy_string` is never used
[INFO] [stdout]    --> src/inspect.rs:340:4
[INFO] [stdout]     |
[INFO] [stdout] 340 | fn read_lossy_string(pid: Pid, address: AddressType) -> InspectResult<String> {
[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: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]   --> src/syscalls.rs:87:3
[INFO] [stdout]    |
[INFO] [stdout] 87 | /   add_key(r#type: *const c_char, description: *const c_char, payload: *const c_void, plen: size_t, keyring: key_serial_t ) /
[INFO] [stdout] 88 | |     { r#type: CString, description: CString, payload: Vec<u8> @ counted_by(raw_args.plen), keyring: key_serial_t }
[INFO] [stdout] 89 | |     -> key_serial_t ~ [] for [x86_64: 248, aarch64: 217, riscv64: 217, loongarch64: 217, powerpc64: 269, s390x: 278],
[INFO] [stdout]    | |___________________________________________________________________________________________________________________^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: `#[deny(self_type_conversion)]` on by default
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 87 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(add_key(r#type: *const c_char, description: *const c_char, payload: *const c_void, plen: size_t, keyring: key_serial_t ) /
[INFO] [stdout] 88 |     { r#type: CString, description: CString, payload: Vec<u8> @ counted_by(raw_args.plen), keyring: key_serial_t }
[INFO] [stdout] 89 ~     -> key_serial_t ~ [] for [x86_64: 248, aarch64: 217, riscv64: 217, loongarch64: 217, powerpc64: 269, s390x: 278)],
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]   --> src/syscalls.rs:91:3
[INFO] [stdout]    |
[INFO] [stdout] 91 |   alarm(seconds: c_uint) / { seconds: c_uint } -> c_uint ~ [] for [x86_64: 37, powerpc64: 27, s390x: 27],
[INFO] [stdout]    |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 91 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(alarm(seconds: c_uint) / { seconds: c_uint } -> c_uint ~ [] for [x86_64: 37, powerpc64: 27, s390x: 27)],
[INFO] [stdout]    |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]   --> src/syscalls.rs:93:3
[INFO] [stdout]    |
[INFO] [stdout] 93 |   arch_prctl(code: c_int, addr: c_ulong) / {} -> c_int ~ [] for [x86_64: 158], // TODO: addr can be a ptr
[INFO] [stdout]    |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 93 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(arch_prctl(code: c_int, addr: c_ulong) / {} -> c_int ~ [] for [x86_64: 158)], // TODO: addr can be a ptr
[INFO] [stdout]    |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                          +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:124:3
[INFO] [stdout]     |
[INFO] [stdout] 124 | /   clock_nanosleep(clockid: clockid_t, flags: c_int, request: *const timespec, remain: *mut timespec) /
[INFO] [stdout] 125 | |   { clockid: clockid_t, flags: c_int, request: timespec } -> c_int + { remain: Option<timespec> }
[INFO] [stdout] 126 | |     ~ [] for [x86_64: 230, aarch64: 115, riscv64: 115, loongarch64: 115, powerpc64: 248, s390x: 262],
[INFO] [stdout]     | |___________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 124 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(clock_nanosleep(clockid: clockid_t, flags: c_int, request: *const timespec, remain: *mut timespec) /
[INFO] [stdout] 125 |   { clockid: clockid_t, flags: c_int, request: timespec } -> c_int + { remain: Option<timespec> }
[INFO] [stdout] 126 ~     ~ [] for [x86_64: 230, aarch64: 115, riscv64: 115, loongarch64: 115, powerpc64: 248, s390x: 262)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:143:3
[INFO] [stdout]     |
[INFO] [stdout] 143 | /   close_range(first: c_uint, last: c_uint, flags: c_uint) / { first: c_uint, last: c_uint, flags: c_uint }
[INFO] [stdout] 144 | |     -> c_int ~ [] for [x86_64: 436, aarch64: 436, riscv64: 436, loongarch64: 436, powerpc64: 436, s390x: 436],
[INFO] [stdout]     | |____________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 143 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(close_range(first: c_uint, last: c_uint, flags: c_uint) / { first: c_uint, last: c_uint, flags: c_uint }
[INFO] [stdout] 144 ~     -> c_int ~ [] for [x86_64: 436, aarch64: 436, riscv64: 436, loongarch64: 436, powerpc64: 436, s390x: 436)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:150:3
[INFO] [stdout]     |
[INFO] [stdout] 150 |   creat(pathname: *const c_char, mode: mode_t) / { pathname: PathBuf, mode: mode_t } -> RawFd ~ [Desc, File] for [x86_64: 85, powerpc64: 8, s390x: 8],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 150 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(creat(pathname: *const c_char, mode: mode_t) / { pathname: PathBuf, mode: mode_t } -> RawFd ~ [Desc, File] for [x86_64: 85, powerpc64: 8, s390x: 8)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                                  +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:151:3
[INFO] [stdout]     |
[INFO] [stdout] 151 |   delete_module(name: *const c_char, flags: c_uint) / { name: CString, flags: c_uint } -> c_int ~ [] for [x86_64: 176, aarch64: 106, riscv64: 106, loongarch64: 106, powerpc64: 129, s390x: 129],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 151 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(delete_module(name: *const c_char, flags: c_uint) / { name: CString, flags: c_uint } -> c_int ~ [] for [x86_64: 176, aarch64: 106, riscv64: 106, loongarch64: 106, powerpc64: 129, s390x: 129)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                                                                             +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:179:3
[INFO] [stdout]     |
[INFO] [stdout] 179 | /   execve(filename: *const c_char, argv: *const *const c_char, envp: *const *const c_char) /
[INFO] [stdout] 180 | |     { filename: PathBuf, argv: Option<Vec<CString>>, envp: Option<Vec<CString>> } -> c_int
[INFO] [stdout] 181 | |     ~ [File, Process] for [x86_64: 59, aarch64: 221, riscv64: 221, loongarch64: 221, powerpc64: 11, s390x: 11],
[INFO] [stdout]     | |_____________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 179 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(execve(filename: *const c_char, argv: *const *const c_char, envp: *const *const c_char) /
[INFO] [stdout] 180 |     { filename: PathBuf, argv: Option<Vec<CString>>, envp: Option<Vec<CString>> } -> c_int
[INFO] [stdout] 181 ~     ~ [File, Process] for [x86_64: 59, aarch64: 221, riscv64: 221, loongarch64: 221, powerpc64: 11, s390x: 11)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:182:3
[INFO] [stdout]     |
[INFO] [stdout] 182 | /   execveat(dirfd: RawFd, pathname: *const c_char, argv: *const *const c_char, envp: *const *const c_char, flags: c_int) /
[INFO] [stdout] 183 | |     { dirfd: RawFd, pathname: PathBuf, argv: Option<Vec<CString>>, envp: Option<Vec<CString>>, flags: c_int }
[INFO] [stdout] 184 | |     -> c_int ~ [Desc, File, Process] for [x86_64: 322, aarch64: 281, riscv64: 281, loongarch64: 281, powerpc64: 362, s390x: 354],
[INFO] [stdout]     | |_______________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 182 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(execveat(dirfd: RawFd, pathname: *const c_char, argv: *const *const c_char, envp: *const *const c_char, flags: c_int) /
[INFO] [stdout] 183 |     { dirfd: RawFd, pathname: PathBuf, argv: Option<Vec<CString>>, envp: Option<Vec<CString>>, flags: c_int }
[INFO] [stdout] 184 ~     -> c_int ~ [Desc, File, Process] for [x86_64: 322, aarch64: 281, riscv64: 281, loongarch64: 281, powerpc64: 362, s390x: 354)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:187:3
[INFO] [stdout]     |
[INFO] [stdout] 187 | /   faccessat(dirfd: RawFd, pathname: *const c_char, mode: c_int) /
[INFO] [stdout] 188 | |     { dirfd: RawFd, pathname: PathBuf, mode: c_int } -> c_int ~ [Desc, File] for [x86_64: 269, aarch64: 48, riscv64: 48, loongarch64: 48, powerpc64: 298, s390x: 300],
[INFO] [stdout]     | |____________________________________________________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 187 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(faccessat(dirfd: RawFd, pathname: *const c_char, mode: c_int) /
[INFO] [stdout] 188 ~     { dirfd: RawFd, pathname: PathBuf, mode: c_int } -> c_int ~ [Desc, File] for [x86_64: 269, aarch64: 48, riscv64: 48, loongarch64: 48, powerpc64: 298, s390x: 300)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:189:3
[INFO] [stdout]     |
[INFO] [stdout] 189 | /   faccessat2(dirfd: RawFd, pathname: *const c_char, mode: c_int, flags: c_int) /
[INFO] [stdout] 190 | |     { dirfd: RawFd, pathname: PathBuf, mode: c_int, flags: c_int } -> c_int ~ [Desc, File] for [x86_64: 439, aarch64: 439, riscv64: 439, loongarch64: 439, powerpc64: 439, s390x: 439],
[INFO] [stdout]     | |_____________________________________________________________________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 189 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(faccessat2(dirfd: RawFd, pathname: *const c_char, mode: c_int, flags: c_int) /
[INFO] [stdout] 190 ~     { dirfd: RawFd, pathname: PathBuf, mode: c_int, flags: c_int } -> c_int ~ [Desc, File] for [x86_64: 439, aarch64: 439, riscv64: 439, loongarch64: 439, powerpc64: 439, s390x: 439)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:199:3
[INFO] [stdout]     |
[INFO] [stdout] 199 | /   fanotify_mark(fanotify_fd: RawFd, flags: c_uint, mask: u64, dirfd: RawFd, pathname: *const c_char) /
[INFO] [stdout] 200 | |     { fanotify_fd: RawFd, flags: c_uint, mask: u64, dirfd: RawFd, pathname: Option<PathBuf> } -> c_int ~ [Desc, File] for [x86_64: 301, aarch64: 263, riscv64: 263, loongarch64: 263, powerpc64: 324, s390x: 333],
[INFO] [stdout]     | |________________________________________________________________________________________________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 199 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(fanotify_mark(fanotify_fd: RawFd, flags: c_uint, mask: u64, dirfd: RawFd, pathname: *const c_char) /
[INFO] [stdout] 200 ~     { fanotify_fd: RawFd, flags: c_uint, mask: u64, dirfd: RawFd, pathname: Option<PathBuf> } -> c_int ~ [Desc, File] for [x86_64: 301, aarch64: 263, riscv64: 263, loongarch64: 263, powerpc64: 324, s390x: 333)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:203:3
[INFO] [stdout]     |
[INFO] [stdout] 203 | /   fchmodat(dirfd: RawFd, pathname: *const c_char, mode: mode_t) /
[INFO] [stdout] 204 | |     { dirfd: RawFd, pathname: PathBuf, mode: mode_t } -> c_int ~ [Desc, File] for [x86_64: 268, aarch64: 53, riscv64: 53, loongarch64: 53, powerpc64: 297, s390x: 299],
[INFO] [stdout]     | |_____________________________________________________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 203 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(fchmodat(dirfd: RawFd, pathname: *const c_char, mode: mode_t) /
[INFO] [stdout] 204 ~     { dirfd: RawFd, pathname: PathBuf, mode: mode_t } -> c_int ~ [Desc, File] for [x86_64: 268, aarch64: 53, riscv64: 53, loongarch64: 53, powerpc64: 297, s390x: 299)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:205:3
[INFO] [stdout]     |
[INFO] [stdout] 205 | /   fchmodat2(dirfd: RawFd, pathname: *const c_char, mode: mode_t, flags: c_int) /
[INFO] [stdout] 206 | |     { dirfd: RawFd, pathname: PathBuf, mode: mode_t, flags: c_int } -> c_int ~ [Desc, File] for [x86_64: 452, aarch64: 452, riscv64: 452, loongarch64: 452, powerpc64: 452, s390x: 452],
[INFO] [stdout]     | |______________________________________________________________________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 205 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(fchmodat2(dirfd: RawFd, pathname: *const c_char, mode: mode_t, flags: c_int) /
[INFO] [stdout] 206 ~     { dirfd: RawFd, pathname: PathBuf, mode: mode_t, flags: c_int } -> c_int ~ [Desc, File] for [x86_64: 452, aarch64: 452, riscv64: 452, loongarch64: 452, powerpc64: 452, s390x: 452)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:209:3
[INFO] [stdout]     |
[INFO] [stdout] 209 | /   fchownat(dirfd: RawFd, pathname: *const c_char, owner: uid_t, group: gid_t, flags: c_int) /
[INFO] [stdout] 210 | |     { dirfd: RawFd, pathname: PathBuf, owner: uid_t, group: gid_t, flags: c_int } -> c_int ~ [Desc, File] for [x86_64: 260, aarch64: 54, riscv64: 54, loongarch64: 54, powerpc64: 289, s390x: 291],
[INFO] [stdout]     | |_________________________________________________________________________________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 209 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(fchownat(dirfd: RawFd, pathname: *const c_char, owner: uid_t, group: gid_t, flags: c_int) /
[INFO] [stdout] 210 ~     { dirfd: RawFd, pathname: PathBuf, owner: uid_t, group: gid_t, flags: c_int } -> c_int ~ [Desc, File] for [x86_64: 260, aarch64: 54, riscv64: 54, loongarch64: 54, powerpc64: 289, s390x: 291)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:218:3
[INFO] [stdout]     |
[INFO] [stdout] 218 | /   file_getattr(dfd: RawFd, filename: *const c_char, fattr: *mut file_attr, size: size_t, at_flags: c_uint) /
[INFO] [stdout] 219 | |     { dfd: RawFd, filename: Option<PathBuf>, size: size_t, at_flags: c_uint } -> c_int + { fattr: file_attr }
[INFO] [stdout] 220 | |     ~ [Desc, File] for [x86_64: 468, aarch64: 468, riscv64: 468, loongarch64: 468, powerpc64: 468, s390x: 468],
[INFO] [stdout]     | |_____________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 218 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(file_getattr(dfd: RawFd, filename: *const c_char, fattr: *mut file_attr, size: size_t, at_flags: c_uint) /
[INFO] [stdout] 219 |     { dfd: RawFd, filename: Option<PathBuf>, size: size_t, at_flags: c_uint } -> c_int + { fattr: file_attr }
[INFO] [stdout] 220 ~     ~ [Desc, File] for [x86_64: 468, aarch64: 468, riscv64: 468, loongarch64: 468, powerpc64: 468, s390x: 468)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:221:3
[INFO] [stdout]     |
[INFO] [stdout] 221 | /   file_setattr(dfd: RawFd, filename: *const c_char, fattr: *const file_attr, size: size_t, at_flags: c_uint) /
[INFO] [stdout] 222 | |     { dfd: RawFd, filename: Option<PathBuf>, fattr: file_attr, size: size_t, at_flags: c_uint } -> c_int
[INFO] [stdout] 223 | |     ~ [Desc, File] for [x86_64: 469, aarch64: 469, riscv64: 469, loongarch64: 469, powerpc64: 469, s390x: 469],
[INFO] [stdout]     | |_____________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 221 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(file_setattr(dfd: RawFd, filename: *const c_char, fattr: *const file_attr, size: size_t, at_flags: c_uint) /
[INFO] [stdout] 222 |     { dfd: RawFd, filename: Option<PathBuf>, fattr: file_attr, size: size_t, at_flags: c_uint } -> c_int
[INFO] [stdout] 223 ~     ~ [Desc, File] for [x86_64: 469, aarch64: 469, riscv64: 469, loongarch64: 469, powerpc64: 469, s390x: 469)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:232:3
[INFO] [stdout]     |
[INFO] [stdout] 232 | /   fsconfig(fd: RawFd, cmd: c_uint, key: *const c_char, value: *const c_char, aux: c_int) /
[INFO] [stdout] 233 | |     { fd: RawFd, cmd: c_uint, key: CString, value: CString, aux: c_int } -> c_int ~ [Desc, File] for [x86_64: 431, aarch64: 431, riscv64: 431, loongarch64: 431, powerpc64: 431, s390x: 431],
[INFO] [stdout]     | |___________________________________________________________________________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 232 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(fsconfig(fd: RawFd, cmd: c_uint, key: *const c_char, value: *const c_char, aux: c_int) /
[INFO] [stdout] 233 ~     { fd: RawFd, cmd: c_uint, key: CString, value: CString, aux: c_int } -> c_int ~ [Desc, File] for [x86_64: 431, aarch64: 431, riscv64: 431, loongarch64: 431, powerpc64: 431, s390x: 431)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:240:3
[INFO] [stdout]     |
[INFO] [stdout] 240 | /   fspick(dirfd: RawFd, pathname: *const c_char, flags: c_uint) / { dirfd: RawFd, pathname: CString, flags: c_uint } -> c_int
[INFO] [stdout] 241 | |     ~ [Desc, File] for [x86_64: 433, aarch64: 433, riscv64: 433, loongarch64: 433, powerpc64: 433, s390x: 433],
[INFO] [stdout]     | |_____________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 240 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(fspick(dirfd: RawFd, pathname: *const c_char, flags: c_uint) / { dirfd: RawFd, pathname: CString, flags: c_uint } -> c_int
[INFO] [stdout] 241 ~     ~ [Desc, File] for [x86_64: 433, aarch64: 433, riscv64: 433, loongarch64: 433, powerpc64: 433, s390x: 433)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:242:3
[INFO] [stdout]     |
[INFO] [stdout] 242 |   fstat(fd: RawFd, statbuf: *mut stat) / { fd: RawFd } -> c_int + { statbuf: stat } ~ [Desc, FStat, StatLike] for [x86_64: 5, aarch64: 80, riscv64: 80, loongarch64: 80, powerpc64: 108, s390x: 108],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 242 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(fstat(fd: RawFd, statbuf: *mut stat) / { fd: RawFd } -> c_int + { statbuf: stat } ~ [Desc, FStat, StatLike] for [x86_64: 5, aarch64: 80, riscv64: 80, loongarch64: 80, powerpc64: 108, s390x: 108)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                                                                                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:244:3
[INFO] [stdout]     |
[INFO] [stdout] 244 |   fstatfs(fd: RawFd, buf: *mut statfs) / { fd: RawFd } -> c_int + { buf: statfs } ~ [Desc, FStatFs, StatFsLike] for [x86_64: 138, aarch64: 44, riscv64: 44, loongarch64: 44, powerpc64: 100, s390x: 100],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 244 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(fstatfs(fd: RawFd, buf: *mut statfs) / { fd: RawFd } -> c_int + { buf: statfs } ~ [Desc, FStatFs, StatFsLike] for [x86_64: 138, aarch64: 44, riscv64: 44, loongarch64: 44, powerpc64: 100, s390x: 100)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                                                                                     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:250:3
[INFO] [stdout]     |
[INFO] [stdout] 250 | /   futex(uaddr: *mut u32, futex_op: c_int, val: u32, val2: usize, uaddr2: *mut u32, val3: u32) /
[INFO] [stdout] 251 | |     { uaddr: InspectResult<u32>, futex_op: c_int, val: u32, val2: usize, uaddr2: InspectResult<u32>, val3: u32 }
[INFO] [stdout] 252 | |     -> c_long + { uaddr: InspectResult<u32>, uaddr2: InspectResult<u32> } ~ [] for [x86_64: 202, aarch64: 98, riscv64: 98, loongarch64: 98, powerpc64: 221, s390x: 238],
[INFO] [stdout]     | |______________________________________________________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 250 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(futex(uaddr: *mut u32, futex_op: c_int, val: u32, val2: usize, uaddr2: *mut u32, val3: u32) /
[INFO] [stdout] 251 |     { uaddr: InspectResult<u32>, futex_op: c_int, val: u32, val2: usize, uaddr2: InspectResult<u32>, val3: u32 }
[INFO] [stdout] 252 ~     -> c_long + { uaddr: InspectResult<u32>, uaddr2: InspectResult<u32> } ~ [] for [x86_64: 202, aarch64: 98, riscv64: 98, loongarch64: 98, powerpc64: 221, s390x: 238)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:255:3
[INFO] [stdout]     |
[INFO] [stdout] 255 | /   futex_requeue(waiters: *mut futex_waitv, flags: c_uint, nr_wake: c_int, nr_requeue: c_int) /
[INFO] [stdout] 256 | |     { waiters: [futex_waitv; 2], flags: c_uint, nr_wake: c_int, nr_requeue: c_int }
[INFO] [stdout] 257 | |     -> c_long + { waiters: [futex_waitv; 2] } ~ [] for [x86_64: 456, aarch64: 456, riscv64: 456, loongarch64: 456, powerpc64: 456, s390x: 456],
[INFO] [stdout]     | |_____________________________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 255 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(futex_requeue(waiters: *mut futex_waitv, flags: c_uint, nr_wake: c_int, nr_requeue: c_int) /
[INFO] [stdout] 256 |     { waiters: [futex_waitv; 2], flags: c_uint, nr_wake: c_int, nr_requeue: c_int }
[INFO] [stdout] 257 ~     -> c_long + { waiters: [futex_waitv; 2] } ~ [] for [x86_64: 456, aarch64: 456, riscv64: 456, loongarch64: 456, powerpc64: 456, s390x: 456)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:259:3
[INFO] [stdout]     |
[INFO] [stdout] 259 | /   futex_wait(uaddr: *mut u32, val: c_ulong, mask: c_ulong, flags: c_uint, timespec: *mut timespec, clockid: clockid_t) /
[INFO] [stdout] 260 | |     { uaddr: InspectResult<u32>, val: c_ulong, mask: c_ulong, flags: c_uint, timespec: timespec, clockid: clockid_t }
[INFO] [stdout] 261 | |     -> c_long + { uaddr: InspectResult<u32> } ~ [] for [x86_64: 455, aarch64: 455, riscv64: 455, loongarch64: 455, powerpc64: 455, s390x: 455],
[INFO] [stdout]     | |_____________________________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 259 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(futex_wait(uaddr: *mut u32, val: c_ulong, mask: c_ulong, flags: c_uint, timespec: *mut timespec, clockid: clockid_t) /
[INFO] [stdout] 260 |     { uaddr: InspectResult<u32>, val: c_ulong, mask: c_ulong, flags: c_uint, timespec: timespec, clockid: clockid_t }
[INFO] [stdout] 261 ~     -> c_long + { uaddr: InspectResult<u32> } ~ [] for [x86_64: 455, aarch64: 455, riscv64: 455, loongarch64: 455, powerpc64: 455, s390x: 455)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:262:3
[INFO] [stdout]     |
[INFO] [stdout] 262 | /   futex_waitv(waiters: *mut futex_waitv, nr_futexes: c_uint, flags: c_uint, timeout: *mut timespec, clockid: clockid_t) /
[INFO] [stdout] 263 | |     { waiters: Vec<futex_waitv> @ counted_by(raw_args.nr_futexes), flags: c_uint, timeout: timespec, clockid: clockid_t }
[INFO] [stdout] 264 | |     -> c_long + { waiters: Vec<futex_waitv> @ counted_by(raw_args.nr_futexes) } ~ [] for [x86_64: 449, aarch64: 449, riscv64: 449, loongarch64: 449, powerpc64: 449, s390x: 449],
[INFO] [stdout]     | |_______________________________________________________________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 262 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(futex_waitv(waiters: *mut futex_waitv, nr_futexes: c_uint, flags: c_uint, timeout: *mut timespec, clockid: clockid_t) /
[INFO] [stdout] 263 |     { waiters: Vec<futex_waitv> @ counted_by(raw_args.nr_futexes), flags: c_uint, timeout: timespec, clockid: clockid_t }
[INFO] [stdout] 264 ~     -> c_long + { waiters: Vec<futex_waitv> @ counted_by(raw_args.nr_futexes) } ~ [] for [x86_64: 449, aarch64: 449, riscv64: 449, loongarch64: 449, powerpc64: 449, s390x: 449)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:265:3
[INFO] [stdout]     |
[INFO] [stdout] 265 | /   futex_wake(uaddr: *mut u32, mask: c_ulong, nr: c_int, flags: c_uint) /
[INFO] [stdout] 266 | |     { uaddr: InspectResult<u32>, mask: c_ulong, nr: c_int, flags: c_uint }
[INFO] [stdout] 267 | |     -> c_long + { uaddr: InspectResult<u32> } ~ [] for [x86_64: 454, aarch64: 454, riscv64: 454, loongarch64: 454, powerpc64: 454, s390x: 454],
[INFO] [stdout]     | |_____________________________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 265 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(futex_wake(uaddr: *mut u32, mask: c_ulong, nr: c_int, flags: c_uint) /
[INFO] [stdout] 266 |     { uaddr: InspectResult<u32>, mask: c_ulong, nr: c_int, flags: c_uint }
[INFO] [stdout] 267 ~     -> c_long + { uaddr: InspectResult<u32> } ~ [] for [x86_64: 454, aarch64: 454, riscv64: 454, loongarch64: 454, powerpc64: 454, s390x: 454)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:268:3
[INFO] [stdout]     |
[INFO] [stdout] 268 | /   futimesat(dirfd: RawFd, pathname: *const c_char, times: *const timeval) /
[INFO] [stdout] 269 | |     { dirfd: RawFd, pathname: PathBuf, times: [timeval;2] } -> c_int ~ [Desc, File] for [x86_64: 261, powerpc64: 290, s390x: 292],
[INFO] [stdout]     | |________________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 268 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(futimesat(dirfd: RawFd, pathname: *const c_char, times: *const timeval) /
[INFO] [stdout] 269 ~     { dirfd: RawFd, pathname: PathBuf, times: [timeval;2] } -> c_int ~ [Desc, File] for [x86_64: 261, powerpc64: 290, s390x: 292)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:276:3
[INFO] [stdout]     |
[INFO] [stdout] 276 | /   get_robust_list(pid: pid_t, head_ptr: *mut *mut robust_list_head, len_ptr: *mut size_t) /
[INFO] [stdout] 277 | |     { pid: pid_t, head_ptr: InspectResult<AddressType>, len_ptr: size_t } -> c_long ~ [] for [x86_64: 274, aarch64: 100, riscv64: 100, loongarch64: 100, powerpc64: 299, s390x: 305],
[INFO] [stdout]     | |___________________________________________________________________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 276 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(get_robust_list(pid: pid_t, head_ptr: *mut *mut robust_list_head, len_ptr: *mut size_t) /
[INFO] [stdout] 277 ~     { pid: pid_t, head_ptr: InspectResult<AddressType>, len_ptr: size_t } -> c_long ~ [] for [x86_64: 274, aarch64: 100, riscv64: 100, loongarch64: 100, powerpc64: 299, s390x: 305)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:278:3
[INFO] [stdout]     |
[INFO] [stdout] 278 |   get_thread_area(u_info: *mut user_desc) / { u_info: user_desc } -> c_int + { u_info: user_desc } ~ [] for [x86_64: 211],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 278 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(get_thread_area(u_info: *mut user_desc) / { u_info: user_desc } -> c_int + { u_info: user_desc } ~ [] for [x86_64: 211)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:279:3
[INFO] [stdout]     |
[INFO] [stdout] 279 | /   getcpu(cpu: *mut c_uint, node: *mut c_uint) /
[INFO] [stdout] 280 | |     { cpu: InspectResult<Option<c_uint>>, node: InspectResult<Option<c_uint>> } -> c_int ~ [] for [x86_64: 309, aarch64: 168, riscv64: 168, loongarch64: 168, powerpc64: 302, s390x: 311],
[INFO] [stdout]     | |________________________________________________________________________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 279 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(getcpu(cpu: *mut c_uint, node: *mut c_uint) /
[INFO] [stdout] 280 ~     { cpu: InspectResult<Option<c_uint>>, node: InspectResult<Option<c_uint>> } -> c_int ~ [] for [x86_64: 309, aarch64: 168, riscv64: 168, loongarch64: 168, powerpc64: 302, s390x: 311)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:291:3
[INFO] [stdout]     |
[INFO] [stdout] 291 |   getegid() / {} -> gid_t ~ [Creds, Pure] for [x86_64: 108, aarch64: 177, riscv64: 177, loongarch64: 177, powerpc64: 50, s390x: 202],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 291 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(getegid() / {} -> gid_t ~ [Creds, Pure] for [x86_64: 108, aarch64: 177, riscv64: 177, loongarch64: 177, powerpc64: 50, s390x: 202)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:293:3
[INFO] [stdout]     |
[INFO] [stdout] 293 |   geteuid() / {} -> uid_t ~ [Creds, Pure] for [x86_64: 107, aarch64: 175, riscv64: 175, loongarch64: 175, powerpc64: 49, s390x: 201],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 293 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(geteuid() / {} -> uid_t ~ [Creds, Pure] for [x86_64: 107, aarch64: 175, riscv64: 175, loongarch64: 175, powerpc64: 49, s390x: 201)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:295:3
[INFO] [stdout]     |
[INFO] [stdout] 295 |   getgid() / {} -> gid_t ~ [Creds, Pure] for [x86_64: 104, aarch64: 176, riscv64: 176, loongarch64: 176, powerpc64: 47, s390x: 200],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 295 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(getgid() / {} -> gid_t ~ [Creds, Pure] for [x86_64: 104, aarch64: 176, riscv64: 176, loongarch64: 176, powerpc64: 47, s390x: 200)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:302:3
[INFO] [stdout]     |
[INFO] [stdout] 302 |   getitimer(which: c_int, value: *mut itimerval) / { which: c_int } -> c_int + { value: itimerval } ~ [] for [x86_64: 36, aarch64: 102, riscv64: 102, loongarch64: 102, powerpc64: 105, s390x: 105],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 302 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(getitimer(which: c_int, value: *mut itimerval) / { which: c_int } -> c_int + { value: itimerval } ~ [] for [x86_64: 36, aarch64: 102, riscv64: 102, loongarch64: 102, powerpc64: 105, s390x: 105)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                                                                                +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:307:3
[INFO] [stdout]     |
[INFO] [stdout] 307 |   getpgid(pid: pid_t) / { pid: pid_t } -> pid_t ~ [] for [x86_64: 121, aarch64: 155, riscv64: 155, loongarch64: 155, powerpc64: 132, s390x: 132],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 307 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(getpgid(pid: pid_t) / { pid: pid_t } -> pid_t ~ [] for [x86_64: 121, aarch64: 155, riscv64: 155, loongarch64: 155, powerpc64: 132, s390x: 132)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                             +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:311:3
[INFO] [stdout]     |
[INFO] [stdout] 311 |   getpriority(which: c_int, who: id_t) / { which: c_int, who: id_t } -> c_int ~ [] for [x86_64: 140, aarch64: 141, riscv64: 141, loongarch64: 141, powerpc64: 96, s390x: 96],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 311 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(getpriority(which: c_int, who: id_t) / { which: c_int, who: id_t } -> c_int ~ [] for [x86_64: 140, aarch64: 141, riscv64: 141, loongarch64: 141, powerpc64: 96, s390x: 96)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                                                         +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:312:3
[INFO] [stdout]     |
[INFO] [stdout] 312 | /   getrandom(buf: *mut c_void, buflen: size_t, flags: c_uint) / { buflen: size_t, flags: c_uint } -> ssize_t + { buf: Vec<u8> @ co...
[INFO] [stdout] 313 | |     ~ [] for [x86_64: 318, aarch64: 278, riscv64: 278, loongarch64: 278, powerpc64: 359, s390x: 349],
[INFO] [stdout]     | |___________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 312 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(getrandom(buf: *mut c_void, buflen: size_t, flags: c_uint) / { buflen: size_t, flags: c_uint } -> ssize_t + { buf: Vec<u8> @ counted_by(raw_args.buflen) }
[INFO] [stdout] 313 ~     ~ [] for [x86_64: 318, aarch64: 278, riscv64: 278, loongarch64: 278, powerpc64: 359, s390x: 349)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:322:3
[INFO] [stdout]     |
[INFO] [stdout] 322 |   getrlimit(resource: c_int, rlim: *mut rlimit) / { resource: c_int } -> c_int + { rlim: rlimit } ~ [] for [x86_64: 97, aarch64: 163, riscv64: 163, s390x: 191],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 322 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(getrlimit(resource: c_int, rlim: *mut rlimit) / { resource: c_int } -> c_int + { rlim: rlimit } ~ [] for [x86_64: 97, aarch64: 163, riscv64: 163, s390x: 191)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                                            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:323:3
[INFO] [stdout]     |
[INFO] [stdout] 323 |   getrusage(who: c_int, usage: *mut rusage) / { who: c_int } -> c_int + { usage: rusage } ~ [] for [x86_64: 98, aarch64: 165, riscv64: 165, loongarch64: 165, powerpc64: 77, s390x: 77],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 323 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(getrusage(who: c_int, usage: *mut rusage) / { who: c_int } -> c_int + { usage: rusage } ~ [] for [x86_64: 98, aarch64: 165, riscv64: 165, loongarch64: 165, powerpc64: 77, s390x: 77)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                                                                    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:324:3
[INFO] [stdout]     |
[INFO] [stdout] 324 |   getsid(pid: pid_t) / { pid: pid_t } -> pid_t ~ [] for [x86_64: 124, aarch64: 156, riscv64: 156, loongarch64: 156, powerpc64: 147, s390x: 147],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 324 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(getsid(pid: pid_t) / { pid: pid_t } -> pid_t ~ [] for [x86_64: 124, aarch64: 156, riscv64: 156, loongarch64: 156, powerpc64: 147, s390x: 147)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:334:3
[INFO] [stdout]     |
[INFO] [stdout] 334 |   getuid() / {} -> uid_t ~ [Creds, Pure] for [x86_64: 102, aarch64: 174, riscv64: 174, loongarch64: 174, powerpc64: 24, s390x: 199],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 334 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(getuid() / {} -> uid_t ~ [Creds, Pure] for [x86_64: 102, aarch64: 174, riscv64: 174, loongarch64: 174, powerpc64: 24, s390x: 199)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:339:3
[INFO] [stdout]     |
[INFO] [stdout] 339 | /   getxattrat(dfd: RawFd, pathname: *const c_char, at_flags: c_uint, name: *const c_char, uargs: *mut c_void, r#usize: size_t) /
[INFO] [stdout] 340 | |     { dfd: RawFd, pathname: PathBuf, at_flags: c_uint, name: CString, uargs: Arc<xattr_args> @ sized_by(raw_args.r#usize) } -> ssize_t ~ [File, Desc] for [x86_64: 464, aarch64: 464, riscv64: 464, loongarch64: 464, powerpc64: 464, s390x: 464],
[INFO] [stdout]     | |________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 339 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(getxattrat(dfd: RawFd, pathname: *const c_char, at_flags: c_uint, name: *const c_char, uargs: *mut c_void, r#usize: size_t) /
[INFO] [stdout] 340 ~     { dfd: RawFd, pathname: PathBuf, at_flags: c_uint, name: CString, uargs: Arc<xattr_args> @ sized_by(raw_args.r#usize) } -> ssize_t ~ [File, Desc] for [x86_64: 464, aarch64: 464, riscv64: 464, loongarch64: 464, powerpc64: 464, s390x: 464)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:344:3
[INFO] [stdout]     |
[INFO] [stdout] 344 | /   init_module(module_image: *mut c_void, len: c_ulong, param_values: *const c_char) /
[INFO] [stdout] 345 | |     { module_image: Vec<u8> @ counted_by(raw_args.len), param_values: CString } -> c_int ~ [] for [x86_64: 175, aarch64: 105, riscv64: 105, loongarch64: 105, powerpc64: 128, s390x: 128],
[INFO] [stdout]     | |________________________________________________________________________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 344 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(init_module(module_image: *mut c_void, len: c_ulong, param_values: *const c_char) /
[INFO] [stdout] 345 ~     { module_image: Vec<u8> @ counted_by(raw_args.len), param_values: CString } -> c_int ~ [] for [x86_64: 175, aarch64: 105, riscv64: 105, loongarch64: 105, powerpc64: 128, s390x: 128)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:346:3
[INFO] [stdout]     |
[INFO] [stdout] 346 | /   inotify_add_watch(fd: RawFd, pathname: *const c_char, mask: u32) /
[INFO] [stdout] 347 | |     { fd: RawFd, pathname: PathBuf, mask: u32 } -> c_int ~ [Desc, File] for [x86_64: 254, aarch64: 27, riscv64: 27, loongarch64: 27, powerpc64: 276, s390x: 285],
[INFO] [stdout]     | |_______________________________________________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 346 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(inotify_add_watch(fd: RawFd, pathname: *const c_char, mask: u32) /
[INFO] [stdout] 347 ~     { fd: RawFd, pathname: PathBuf, mask: u32 } -> c_int ~ [Desc, File] for [x86_64: 254, aarch64: 27, riscv64: 27, loongarch64: 27, powerpc64: 276, s390x: 285)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:351:3
[INFO] [stdout]     |
[INFO] [stdout] 351 | /   io_cancel(ctx_id: aio_context_t, iocb: *mut iocb, result: *mut io_event) /
[INFO] [stdout] 352 | |     { ctx_id: aio_context_t, iocb: iocb } -> c_int + { result: io_event } ~ [] for [x86_64: 210, aarch64: 3, riscv64: 3, loongarch64: 3, powerpc64: 231, s390x: 247],
[INFO] [stdout]     | |___________________________________________________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 351 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(io_cancel(ctx_id: aio_context_t, iocb: *mut iocb, result: *mut io_event) /
[INFO] [stdout] 352 ~     { ctx_id: aio_context_t, iocb: iocb } -> c_int + { result: io_event } ~ [] for [x86_64: 210, aarch64: 3, riscv64: 3, loongarch64: 3, powerpc64: 231, s390x: 247)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:354:3
[INFO] [stdout]     |
[INFO] [stdout] 354 |   io_destroy(ctx_id: aio_context_t) / { ctx_id: aio_context_t } -> c_int ~ [] for [x86_64: 207, aarch64: 1, riscv64: 1, loongarch64: 1, powerpc64: 228, s390x: 244],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 354 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(io_destroy(ctx_id: aio_context_t) / { ctx_id: aio_context_t } -> c_int ~ [] for [x86_64: 207, aarch64: 1, riscv64: 1, loongarch64: 1, powerpc64: 228, s390x: 244)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                                                +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:356:3
[INFO] [stdout]     |
[INFO] [stdout] 356 | /   io_getevents(ctx_id: aio_context_t, min_nr: c_long, nr: c_long, events: *mut io_event, timeout: *mut timespec) /
[INFO] [stdout] 357 | |     { ctx_id: aio_context_t, min_nr: c_long, nr: c_long, timeout: Option<timespec> }
[INFO] [stdout] 358 | |     -> c_int + { events: Vec<io_event> @ counted_by(syscall_result) } ~ [] for [x86_64: 208, aarch64: 4, riscv64: 4, loongarch64: 4, powerpc64: 229, s390x: 245],
[INFO] [stdout]     | |_______________________________________________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 356 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(io_getevents(ctx_id: aio_context_t, min_nr: c_long, nr: c_long, events: *mut io_event, timeout: *mut timespec) /
[INFO] [stdout] 357 |     { ctx_id: aio_context_t, min_nr: c_long, nr: c_long, timeout: Option<timespec> }
[INFO] [stdout] 358 ~     -> c_int + { events: Vec<io_event> @ counted_by(syscall_result) } ~ [] for [x86_64: 208, aarch64: 4, riscv64: 4, loongarch64: 4, powerpc64: 229, s390x: 245)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:359:3
[INFO] [stdout]     |
[INFO] [stdout] 359 | /   io_pgetevents(ctx_id: aio_context_t, min_nr: c_long, nr: c_long, events: *mut io_event, timeout: *mut timespec, sig: *const __aio_sigset) /
[INFO] [stdout] 360 | |     { ctx_id: aio_context_t, min_nr: c_long, nr: c_long, timeout: Option<timespec>, sig: __aio_sigset }
[INFO] [stdout] 361 | |     -> c_int + { events: Vec<io_event> @ counted_by(syscall_result) } ~ [] for [x86_64: 333, aarch64: 292, riscv64: 292, loongarch64: 292, powerpc64: 388, s390x: 382],
[INFO] [stdout]     | |_____________________________________________________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 359 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(io_pgetevents(ctx_id: aio_context_t, min_nr: c_long, nr: c_long, events: *mut io_event, timeout: *mut timespec, sig: *const __aio_sigset) /
[INFO] [stdout] 360 |     { ctx_id: aio_context_t, min_nr: c_long, nr: c_long, timeout: Option<timespec>, sig: __aio_sigset }
[INFO] [stdout] 361 ~     -> c_int + { events: Vec<io_event> @ counted_by(syscall_result) } ~ [] for [x86_64: 333, aarch64: 292, riscv64: 292, loongarch64: 292, powerpc64: 388, s390x: 382)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:366:3
[INFO] [stdout]     |
[INFO] [stdout] 366 | /   io_submit(ctx: aio_context_t, nr: c_long, iocbs: *mut *mut iocb) /
[INFO] [stdout] 367 | |     { ctx: aio_context_t, iocbs: Vec<AddressType> @ counted_by(raw_args.nr) } -> c_int ~ [] for [x86_64: 209, aarch64: 2, riscv64: 2, loongarch64: 2, powerpc64: 230, s390x: 246],
[INFO] [stdout]     | |________________________________________________________________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 366 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(io_submit(ctx: aio_context_t, nr: c_long, iocbs: *mut *mut iocb) /
[INFO] [stdout] 367 ~     { ctx: aio_context_t, iocbs: Vec<AddressType> @ counted_by(raw_args.nr) } -> c_int ~ [] for [x86_64: 209, aarch64: 2, riscv64: 2, loongarch64: 2, powerpc64: 230, s390x: 246)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:369:3
[INFO] [stdout]     |
[INFO] [stdout] 369 | /   io_uring_enter(fd: c_uint, to_submit: c_uint, min_complete: c_uint, flags: c_uint, arg: AddressType, argsz: size_t) /
[INFO] [stdout] 370 | |     { fd: c_uint, to_submit: c_uint, min_complete: c_uint, flags: c_uint, arg: Vec<u8> @ counted_by(raw_args.argsz) }
[INFO] [stdout] 371 | |     -> c_int ~ [Desc, File] for [x86_64: 426, aarch64: 426, riscv64: 426, loongarch64: 426, powerpc64: 426, s390x: 426],
[INFO] [stdout]     | |______________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 369 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(io_uring_enter(fd: c_uint, to_submit: c_uint, min_complete: c_uint, flags: c_uint, arg: AddressType, argsz: size_t) /
[INFO] [stdout] 370 |     { fd: c_uint, to_submit: c_uint, min_complete: c_uint, flags: c_uint, arg: Vec<u8> @ counted_by(raw_args.argsz) }
[INFO] [stdout] 371 ~     -> c_int ~ [Desc, File] for [x86_64: 426, aarch64: 426, riscv64: 426, loongarch64: 426, powerpc64: 426, s390x: 426)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:373:3
[INFO] [stdout]     |
[INFO] [stdout] 373 | /   io_uring_register(fd: c_uint, op: c_uint, arg: AddressType, nr_args: c_uint) /
[INFO] [stdout] 374 | |     { fd: c_uint, op: c_uint, arg: AddressType, nr_args: c_uint } -> c_int ~ [Desc, Memory] for [x86_64: 427, aarch64: 427, riscv64: 427, loongarch64: 427, powerpc64: 427, s390x: 427],
[INFO] [stdout]     | |______________________________________________________________________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 373 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(io_uring_register(fd: c_uint, op: c_uint, arg: AddressType, nr_args: c_uint) /
[INFO] [stdout] 374 ~     { fd: c_uint, op: c_uint, arg: AddressType, nr_args: c_uint } -> c_int ~ [Desc, Memory] for [x86_64: 427, aarch64: 427, riscv64: 427, loongarch64: 427, powerpc64: 427, s390x: 427)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:379:3
[INFO] [stdout]     |
[INFO] [stdout] 379 |   ioperm(from: c_ulong, num: c_ulong, turn_on: c_int) / { from: c_ulong, num: c_ulong, turn_on: c_int } -> c_int ~ [] for [x86_64: 173],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 379 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(ioperm(from: c_ulong, num: c_ulong, turn_on: c_int) / { from: c_ulong, num: c_ulong, turn_on: c_int } -> c_int ~ [] for [x86_64: 173)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:380:3
[INFO] [stdout]     |
[INFO] [stdout] 380 |   iopl(level: c_int) / { level: c_int } -> c_int ~ [] for [x86_64: 172],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 380 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(iopl(level: c_int) / { level: c_int } -> c_int ~ [] for [x86_64: 172)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:381:3
[INFO] [stdout]     |
[INFO] [stdout] 381 |   ioprio_get(which: c_int, who: c_int) / { which: c_int, who: c_int } -> c_int ~ [] for [x86_64: 252, aarch64: 31, riscv64: 31, loongarch64: 31, powerpc64: 274, s390x: 283],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 381 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(ioprio_get(which: c_int, who: c_int) / { which: c_int, who: c_int } -> c_int ~ [] for [x86_64: 252, aarch64: 31, riscv64: 31, loongarch64: 31, powerpc64: 274, s390x: 283)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                                                         +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:382:3
[INFO] [stdout]     |
[INFO] [stdout] 382 |   ioprio_set(which: c_int, who: c_int, ioprio: c_int) / { which: c_int, who: c_int, ioprio: c_int } -> c_int ~ [] for [x86_64: 251, aarch64: 30, riscv64: 30, loongarch64: 30, powerpc64: 273, s390x: 282],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 382 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(ioprio_set(which: c_int, who: c_int, ioprio: c_int) / { which: c_int, who: c_int, ioprio: c_int } -> c_int ~ [] for [x86_64: 251, aarch64: 30, riscv64: 30, loongarch64: 30, powerpc64: 273, s390x: 282)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                                                                                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:384:3
[INFO] [stdout]     |
[INFO] [stdout] 384 | /   kcmp(pid1: pid_t, pid2: pid_t, r#type: c_int, idx1: c_ulong, idx2: c_ulong) /
[INFO] [stdout] 385 | |     { pid1: pid_t, pid2: pid_t, r#type: c_int, idx1: c_ulong, idx2: c_ulong } -> c_int ~ [] for [x86_64: 312, aarch64: 272, riscv64: 272, loongarch64: 272, powerpc64: 354, s390x: 343],
[INFO] [stdout]     | |______________________________________________________________________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 384 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(kcmp(pid1: pid_t, pid2: pid_t, r#type: c_int, idx1: c_ulong, idx2: c_ulong) /
[INFO] [stdout] 385 ~     { pid1: pid_t, pid2: pid_t, r#type: c_int, idx1: c_ulong, idx2: c_ulong } -> c_int ~ [] for [x86_64: 312, aarch64: 272, riscv64: 272, loongarch64: 272, powerpc64: 354, s390x: 343)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:390:3
[INFO] [stdout]     |
[INFO] [stdout] 390 | /   kexec_load(entry: c_ulong, nr_segments: c_ulong, segments: *mut kexec_segment, flags: c_ulong) /
[INFO] [stdout] 391 | |     { entry: c_ulong, segments: Vec<kexec_segment> @ counted_by(raw_args.nr_segments), flags: c_ulong } -> c_long
[INFO] [stdout] 392 | |     ~ [] for [x86_64: 246, aarch64: 104, riscv64: 104, loongarch64: 104, powerpc64: 268, s390x: 277],
[INFO] [stdout]     | |___________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 390 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(kexec_load(entry: c_ulong, nr_segments: c_ulong, segments: *mut kexec_segment, flags: c_ulong) /
[INFO] [stdout] 391 |     { entry: c_ulong, segments: Vec<kexec_segment> @ counted_by(raw_args.nr_segments), flags: c_ulong } -> c_long
[INFO] [stdout] 392 ~     ~ [] for [x86_64: 246, aarch64: 104, riscv64: 104, loongarch64: 104, powerpc64: 268, s390x: 277)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:393:3
[INFO] [stdout]     |
[INFO] [stdout] 393 | /   keyctl(option: c_int, arg2: c_ulong, arg3: c_ulong, arg4: c_ulong, arg5: c_ulong) /
[INFO] [stdout] 394 | |     { option: c_int, arg2: c_ulong, arg3: c_ulong, arg4: c_ulong, arg5: c_ulong } -> c_long ~ [] for [x86_64: 250, aarch64: 219, riscv64: 219, loongarch64: 219, powerpc64: 271, s390x: 280],
[INFO] [stdout]     | |___________________________________________________________________________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 393 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(keyctl(option: c_int, arg2: c_ulong, arg3: c_ulong, arg4: c_ulong, arg5: c_ulong) /
[INFO] [stdout] 394 ~     { option: c_int, arg2: c_ulong, arg3: c_ulong, arg4: c_ulong, arg5: c_ulong } -> c_long ~ [] for [x86_64: 250, aarch64: 219, riscv64: 219, loongarch64: 219, powerpc64: 271, s390x: 280)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:395:3
[INFO] [stdout]     |
[INFO] [stdout] 395 |   kill(pid: pid_t, sig: c_int) / { pid: pid_t, sig: c_int } -> c_int ~ [Signal, Process] for [x86_64: 62, aarch64: 129, riscv64: 129, loongarch64: 129, powerpc64: 37, s390x: 37],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 395 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(kill(pid: pid_t, sig: c_int) / { pid: pid_t, sig: c_int } -> c_int ~ [Signal, Process] for [x86_64: 62, aarch64: 129, riscv64: 129, loongarch64: 129, powerpc64: 37, s390x: 37)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                                                              +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:407:3
[INFO] [stdout]     |
[INFO] [stdout] 407 | /   linkat(olddirfd: RawFd, oldpath: *const c_char, newdirfd: RawFd, newpath: *const c_char, flags: c_int) /
[INFO] [stdout] 408 | |     { olddirfd: RawFd, oldpath: PathBuf, newdirfd: RawFd, newpath: PathBuf, flags: c_int } -> c_int
[INFO] [stdout] 409 | |     ~ [Desc, File] for [x86_64: 265, aarch64: 37, riscv64: 37, loongarch64: 37, powerpc64: 294, s390x: 296],
[INFO] [stdout]     | |__________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 407 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(linkat(olddirfd: RawFd, oldpath: *const c_char, newdirfd: RawFd, newpath: *const c_char, flags: c_int) /
[INFO] [stdout] 408 |     { olddirfd: RawFd, oldpath: PathBuf, newdirfd: RawFd, newpath: PathBuf, flags: c_int } -> c_int
[INFO] [stdout] 409 ~     ~ [Desc, File] for [x86_64: 265, aarch64: 37, riscv64: 37, loongarch64: 37, powerpc64: 294, s390x: 296)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:412:3
[INFO] [stdout]     |
[INFO] [stdout] 412 | /   listmount(req: *const __mount_arg, buf: *mut u64, bufsize: size_t, flags: c_uint) /
[INFO] [stdout] 413 | |     { req: __mount_arg, bufsize: size_t, flags: c_uint } -> c_int + { buf: Vec<u64> @ counted_by(raw_args.bufsize) }
[INFO] [stdout] 414 | |      ~ [] for [x86_64: 458, aarch64: 458, riscv64: 458, loongarch64: 458, powerpc64: 458, s390x: 458],
[INFO] [stdout]     | |____________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 412 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(listmount(req: *const __mount_arg, buf: *mut u64, bufsize: size_t, flags: c_uint) /
[INFO] [stdout] 413 |     { req: __mount_arg, bufsize: size_t, flags: c_uint } -> c_int + { buf: Vec<u64> @ counted_by(raw_args.bufsize) }
[INFO] [stdout] 414 ~      ~ [] for [x86_64: 458, aarch64: 458, riscv64: 458, loongarch64: 458, powerpc64: 458, s390x: 458)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:415:3
[INFO] [stdout]     |
[INFO] [stdout] 415 | /   listns(req: *const ns_id_req, ns_ids: *mut u64, nr_ns_ids: size_t, flags: c_uint) /
[INFO] [stdout] 416 | |     { req: ns_id_req, nr_ns_ids: size_t, flags: c_uint } -> ssize_t + { ns_ids: Vec<u64> @ counted_by(syscall_result) }
[INFO] [stdout] 417 | |     ~ [] for [x86_64: 470, aarch64: 470, riscv64: 470, loongarch64: 470, powerpc64: 470, s390x: 470],
[INFO] [stdout]     | |___________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 415 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(listns(req: *const ns_id_req, ns_ids: *mut u64, nr_ns_ids: size_t, flags: c_uint) /
[INFO] [stdout] 416 |     { req: ns_id_req, nr_ns_ids: size_t, flags: c_uint } -> ssize_t + { ns_ids: Vec<u64> @ counted_by(syscall_result) }
[INFO] [stdout] 417 ~     ~ [] for [x86_64: 470, aarch64: 470, riscv64: 470, loongarch64: 470, powerpc64: 470, s390x: 470)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:422:3
[INFO] [stdout]     |
[INFO] [stdout] 422 | /   listxattrat(dfd: RawFd, pathname: *const c_char, at_flags: c_uint, list: *mut c_char, size: size_t) /
[INFO] [stdout] 423 | |     { dfd: RawFd, pathname: PathBuf, at_flags: c_uint, size: size_t } -> ssize_t + { list: Option<Vec<CString>> }
[INFO] [stdout] 424 | |     ~ [File, Desc] for [x86_64: 465, aarch64: 465, riscv64: 465, loongarch64: 465, powerpc64: 465, s390x: 465],
[INFO] [stdout]     | |_____________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 422 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(listxattrat(dfd: RawFd, pathname: *const c_char, at_flags: c_uint, list: *mut c_char, size: size_t) /
[INFO] [stdout] 423 |     { dfd: RawFd, pathname: PathBuf, at_flags: c_uint, size: size_t } -> ssize_t + { list: Option<Vec<CString>> }
[INFO] [stdout] 424 ~     ~ [File, Desc] for [x86_64: 465, aarch64: 465, riscv64: 465, loongarch64: 465, powerpc64: 465, s390x: 465)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:425:3
[INFO] [stdout]     |
[INFO] [stdout] 425 | /   lookup_dcookie(cookie: u64, buffer: *mut c_char, len: size_t) /
[INFO] [stdout] 426 | |     { cookie: u64, len: size_t } -> c_long + { buffer: PathBuf } ~ [] for [x86_64: 212, aarch64: 18, riscv64: 18, loongarch64: 18],
[INFO] [stdout]     | |_________________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 425 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(lookup_dcookie(cookie: u64, buffer: *mut c_char, len: size_t) /
[INFO] [stdout] 426 ~     { cookie: u64, len: size_t } -> c_long + { buffer: PathBuf } ~ [] for [x86_64: 212, aarch64: 18, riscv64: 18, loongarch64: 18)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:433:3
[INFO] [stdout]     |
[INFO] [stdout] 433 | /   lsm_get_self_attr(attr: c_uint, ctx: *mut c_void, size: *mut u32, flags: u32) / { attr: c_uint, size: InspectResult<u32>, flags:...
[INFO] [stdout] 434 | |     -> c_int + { ctx: Vec<u8> } ~ [] for [x86_64: 459, aarch64: 459, riscv64: 459, loongarch64: 459, powerpc64: 459, s390x: 459],
[INFO] [stdout]     | |_______________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 433 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(lsm_get_self_attr(attr: c_uint, ctx: *mut c_void, size: *mut u32, flags: u32) / { attr: c_uint, size: InspectResult<u32>, flags: u32 }
[INFO] [stdout] 434 ~     -> c_int + { ctx: Vec<u8> } ~ [] for [x86_64: 459, aarch64: 459, riscv64: 459, loongarch64: 459, powerpc64: 459, s390x: 459)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:435:3
[INFO] [stdout]     |
[INFO] [stdout] 435 | /   lsm_list_modules(ids: *mut u64, size: *mut u32, flags: u32) / { size: InspectResult<u32>, flags: u32 }
[INFO] [stdout] 436 | |     -> c_int + { size: InspectResult<u32>, ids: Vec<u64> @ counted_by_result(size) } ~ [] for [x86_64: 461, aarch64: 461, riscv64: 461, loongarch64: 461, powerpc64: 461, s390x: 461],
[INFO] [stdout]     | |____________________________________________________________________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 435 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(lsm_list_modules(ids: *mut u64, size: *mut u32, flags: u32) / { size: InspectResult<u32>, flags: u32 }
[INFO] [stdout] 436 ~     -> c_int + { size: InspectResult<u32>, ids: Vec<u64> @ counted_by_result(size) } ~ [] for [x86_64: 461, aarch64: 461, riscv64: 461, loongarch64: 461, powerpc64: 461, s390x: 461)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:437:3
[INFO] [stdout]     |
[INFO] [stdout] 437 | /   lsm_set_self_attr(attr: c_uint, ctx: *const c_void, size: u32, flags: u32) /
[INFO] [stdout] 438 | |     { attr: c_uint, ctx: Vec<u8> @ counted_by(raw_args.size), flags: u32 } -> c_int ~ [] for [x86_64: 460, aarch64: 460, riscv64: 460, loongarch64: 460, powerpc64: 460, s390x: 460],
[INFO] [stdout]     | |___________________________________________________________________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 437 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(lsm_set_self_attr(attr: c_uint, ctx: *const c_void, size: u32, flags: u32) /
[INFO] [stdout] 438 ~     { attr: c_uint, ctx: Vec<u8> @ counted_by(raw_args.size), flags: u32 } -> c_int ~ [] for [x86_64: 460, aarch64: 460, riscv64: 460, loongarch64: 460, powerpc64: 460, s390x: 460)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:439:3
[INFO] [stdout]     |
[INFO] [stdout] 439 |   lstat(pathname: *const c_char, statbuf: *mut stat) / { pathname: PathBuf } -> c_int + { statbuf: stat } ~ [File, LStat, StatLike] for [x86_64: 6, powerpc64: 107, s390x: 107],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 439 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(lstat(pathname: *const c_char, statbuf: *mut stat) / { pathname: PathBuf } -> c_int + { statbuf: stat } ~ [File, LStat, StatLike] for [x86_64: 6, powerpc64: 107, s390x: 107)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                                                            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:465:3
[INFO] [stdout]     |
[INFO] [stdout] 465 | /   mkdirat(dirfd: RawFd, pathname: *const c_char, mode: mode_t) / { dirfd: RawFd, pathname: PathBuf, mode: mode_t } -> c_int
[INFO] [stdout] 466 | |     ~ [Desc, File] for [x86_64: 258, aarch64: 34, riscv64: 34, loongarch64: 34, powerpc64: 287, s390x: 289],
[INFO] [stdout]     | |__________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 465 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(mkdirat(dirfd: RawFd, pathname: *const c_char, mode: mode_t) / { dirfd: RawFd, pathname: PathBuf, mode: mode_t } -> c_int
[INFO] [stdout] 466 ~     ~ [Desc, File] for [x86_64: 258, aarch64: 34, riscv64: 34, loongarch64: 34, powerpc64: 287, s390x: 289)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:468:3
[INFO] [stdout]     |
[INFO] [stdout] 468 | /   mknodat(dirfd: RawFd, pathname: *const c_char, mode: mode_t, dev: dev_t) /
[INFO] [stdout] 469 | |     { dirfd: RawFd, pathname: PathBuf, mode: mode_t, dev: dev_t } -> c_int ~ [Desc, File] for [x86_64: 259, aarch64: 33, riscv64: 33, loongarch64: 33, powerpc64: 288, s390x: 290],
[INFO] [stdout]     | |_________________________________________________________________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 468 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(mknodat(dirfd: RawFd, pathname: *const c_char, mode: mode_t, dev: dev_t) /
[INFO] [stdout] 469 ~     { dirfd: RawFd, pathname: PathBuf, mode: mode_t, dev: dev_t } -> c_int ~ [Desc, File] for [x86_64: 259, aarch64: 33, riscv64: 33, loongarch64: 33, powerpc64: 288, s390x: 290)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:479:3
[INFO] [stdout]     |
[INFO] [stdout] 479 | /   modify_ldt(func: c_int, ptr: *mut c_void, bytecount: c_ulong) / { func: c_int, ptr: AddressType, bytecount: c_ulong } -> c_int
[INFO] [stdout] 480 | |     ~ [] for [x86_64: 154],
[INFO] [stdout]     | |_________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 479 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(modify_ldt(func: c_int, ptr: *mut c_void, bytecount: c_ulong) / { func: c_int, ptr: AddressType, bytecount: c_ulong } -> c_int
[INFO] [stdout] 480 ~     ~ [] for [x86_64: 154)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:484:3
[INFO] [stdout]     |
[INFO] [stdout] 484 | /   mount_setattr(dirfd: RawFd, pathname: *const c_char, flags: c_uint, uattr: *mut c_void, r#usize: size_t) /
[INFO] [stdout] 485 | |     { dirfd: RawFd, pathname: PathBuf, flags: c_uint, uattr: Arc<mount_attr> @ sized_by(raw_args.r#usize) } -> c_int
[INFO] [stdout] 486 | |     ~ [Desc, File] for [x86_64: 442, aarch64: 442, riscv64: 442, loongarch64: 442, powerpc64: 442, s390x: 442],
[INFO] [stdout]     | |_____________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 484 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(mount_setattr(dirfd: RawFd, pathname: *const c_char, flags: c_uint, uattr: *mut c_void, r#usize: size_t) /
[INFO] [stdout] 485 |     { dirfd: RawFd, pathname: PathBuf, flags: c_uint, uattr: Arc<mount_attr> @ sized_by(raw_args.r#usize) } -> c_int
[INFO] [stdout] 486 ~     ~ [Desc, File] for [x86_64: 442, aarch64: 442, riscv64: 442, loongarch64: 442, powerpc64: 442, s390x: 442)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:487:3
[INFO] [stdout]     |
[INFO] [stdout] 487 | /   move_mount(from_dfd: RawFd, from_path: *const c_char, to_dfd: RawFd, to_path: *const c_char, ms_flags: c_uint) /
[INFO] [stdout] 488 | |     { from_dfd: RawFd, from_path: PathBuf, to_dfd: RawFd, to_path: PathBuf, ms_flags: c_uint } -> c_int
[INFO] [stdout] 489 | |     ~ [Desc, File] for [x86_64: 429, aarch64: 429, riscv64: 429, loongarch64: 429, powerpc64: 429, s390x: 429],
[INFO] [stdout]     | |_____________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 487 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(move_mount(from_dfd: RawFd, from_path: *const c_char, to_dfd: RawFd, to_path: *const c_char, ms_flags: c_uint) /
[INFO] [stdout] 488 |     { from_dfd: RawFd, from_path: PathBuf, to_dfd: RawFd, to_path: PathBuf, ms_flags: c_uint } -> c_int
[INFO] [stdout] 489 ~     ~ [Desc, File] for [x86_64: 429, aarch64: 429, riscv64: 429, loongarch64: 429, powerpc64: 429, s390x: 429)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:515:3
[INFO] [stdout]     |
[INFO] [stdout] 515 |   mq_unlink(name: *const c_char) / { name: CString } -> c_int ~ [] for [x86_64: 241, aarch64: 181, riscv64: 181, loongarch64: 181, powerpc64: 263, s390x: 272],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 515 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(mq_unlink(name: *const c_char) / { name: CString } -> c_int ~ [] for [x86_64: 241, aarch64: 181, riscv64: 181, loongarch64: 181, powerpc64: 263, s390x: 272)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                                           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:522:3
[INFO] [stdout]     |
[INFO] [stdout] 522 | /   msgctl(msqid: c_int, cmd: c_int, buf: *mut msqid_ds) / { msqid: c_int, cmd: c_int } -> c_int + { buf: msqid_ds }
[INFO] [stdout] 523 | |     ~ [] for [x86_64: 71, aarch64: 187, riscv64: 187, loongarch64: 187, powerpc64: 402, s390x: 402],
[INFO] [stdout]     | |__________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 522 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(msgctl(msqid: c_int, cmd: c_int, buf: *mut msqid_ds) / { msqid: c_int, cmd: c_int } -> c_int + { buf: msqid_ds }
[INFO] [stdout] 523 ~     ~ [] for [x86_64: 71, aarch64: 187, riscv64: 187, loongarch64: 187, powerpc64: 402, s390x: 402)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:524:3
[INFO] [stdout]     |
[INFO] [stdout] 524 |   msgget(key: key_t, msgflg: c_int) / { key: key_t, msgflg: c_int } -> c_int ~ [] for [x86_64: 68, aarch64: 186, riscv64: 186, loongarch64: 186, powerpc64: 399, s390x: 399],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 524 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(msgget(key: key_t, msgflg: c_int) / { key: key_t, msgflg: c_int } -> c_int ~ [] for [x86_64: 68, aarch64: 186, riscv64: 186, loongarch64: 186, powerpc64: 399, s390x: 399)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                                                         +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:525:3
[INFO] [stdout]     |
[INFO] [stdout] 525 | /   msgrcv(msqid: c_int, msgp: *mut c_void, msgsz: size_t, msgtyp: c_long, msgflg: c_int) /
[INFO] [stdout] 526 | |     { msqid: c_int, msgsz: size_t, msgtyp: c_long, msgflg: c_int } -> ssize_t + { msgp: Arc<msgbuf> @ sized_by(size_of::<c_long>(...
[INFO] [stdout] 527 | |     ~ [] for [x86_64: 70, aarch64: 188, riscv64: 188, loongarch64: 188, powerpc64: 401, s390x: 401],
[INFO] [stdout]     | |__________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 525 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(msgrcv(msqid: c_int, msgp: *mut c_void, msgsz: size_t, msgtyp: c_long, msgflg: c_int) /
[INFO] [stdout] 526 |     { msqid: c_int, msgsz: size_t, msgtyp: c_long, msgflg: c_int } -> ssize_t + { msgp: Arc<msgbuf> @ sized_by(size_of::<c_long>() + syscall_result as usize) }
[INFO] [stdout] 527 ~     ~ [] for [x86_64: 70, aarch64: 188, riscv64: 188, loongarch64: 188, powerpc64: 401, s390x: 401)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:528:3
[INFO] [stdout]     |
[INFO] [stdout] 528 | /   msgsnd(msqid: c_int, msgp: *const c_void, msgsz: size_t, msgflg: c_int) /
[INFO] [stdout] 529 | |     { msqid: c_int, msgp: Arc<msgbuf> @ sized_by(size_of::<c_long>() + raw_args.msgsz as usize), msgflg: c_int } -> c_int ~ [] for [x86_64: 69, aarch64: 189, riscv64: 189, loongarch64: 189, powerpc64: 400, s390x: 400],
[INFO] [stdout]     | |________________________________________________________________________________________________________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 528 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(msgsnd(msqid: c_int, msgp: *const c_void, msgsz: size_t, msgflg: c_int) /
[INFO] [stdout] 529 ~     { msqid: c_int, msgp: Arc<msgbuf> @ sized_by(size_of::<c_long>() + raw_args.msgsz as usize), msgflg: c_int } -> c_int ~ [] for [x86_64: 69, aarch64: 189, riscv64: 189, loongarch64: 189, powerpc64: 400, s390x: 400)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:536:3
[INFO] [stdout]     |
[INFO] [stdout] 536 | /   name_to_handle_at(dirfd: RawFd, pathname: *const c_char, handle: *mut c_void, mount_id: *mut c_int, flags: c_int) /
[INFO] [stdout] 537 | |     { dirfd: RawFd, pathname: PathBuf, flags: c_int } -> c_int +
[INFO] [stdout] 538 | |     { handle: Arc<file_handle> @ sized_by_result(<InspectResult<c_uint> as InspectFromPid>::inspect_from(inspectee_pid, raw_args....
[INFO] [stdout] 539 | |       mount_id: InspectResult<c_int> }
[INFO] [stdout] 540 | |     ~ [Desc, File] for [x86_64: 303, aarch64: 264, riscv64: 264, loongarch64: 264, powerpc64: 345, s390x: 335],
[INFO] [stdout]     | |_____________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 536 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(name_to_handle_at(dirfd: RawFd, pathname: *const c_char, handle: *mut c_void, mount_id: *mut c_int, flags: c_int) /
[INFO] [stdout] 537 |     { dirfd: RawFd, pathname: PathBuf, flags: c_int } -> c_int +
[INFO] [stdout] 538 |     { handle: Arc<file_handle> @ sized_by_result(<InspectResult<c_uint> as InspectFromPid>::inspect_from(inspectee_pid, raw_args.handle as AddressType)),
[INFO] [stdout] 539 |       mount_id: InspectResult<c_int> }
[INFO] [stdout] 540 ~     ~ [Desc, File] for [x86_64: 303, aarch64: 264, riscv64: 264, loongarch64: 264, powerpc64: 345, s390x: 335)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:543:3
[INFO] [stdout]     |
[INFO] [stdout] 543 | /   newfstatat(dirfd: RawFd, pathname: *const c_char, statbuf: *mut stat, flags: c_int) /
[INFO] [stdout] 544 | |     { dirfd: RawFd, pathname: PathBuf, flags: c_int } -> c_int + { statbuf: stat }
[INFO] [stdout] 545 | |     ~ [Desc, File, FStat, StatLike] for [x86_64: 262, aarch64: 79, riscv64: 79, loongarch64: 79, powerpc64: 291, s390x: 293],
[INFO] [stdout]     | |___________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 543 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(newfstatat(dirfd: RawFd, pathname: *const c_char, statbuf: *mut stat, flags: c_int) /
[INFO] [stdout] 544 |     { dirfd: RawFd, pathname: PathBuf, flags: c_int } -> c_int + { statbuf: stat }
[INFO] [stdout] 545 ~     ~ [Desc, File, FStat, StatLike] for [x86_64: 262, aarch64: 79, riscv64: 79, loongarch64: 79, powerpc64: 291, s390x: 293)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:554:3
[INFO] [stdout]     |
[INFO] [stdout] 554 | /   open(pathname: *const c_char, flags: c_int, mode: mode_t) / { pathname: PathBuf, flags: c_int, mode: mode_t } -> RawFd
[INFO] [stdout] 555 | |     ~ [Desc, File] for [x86_64: 2, aarch64: 56, riscv64: 56, powerpc64: 5, s390x: 5],
[INFO] [stdout]     | |___________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 554 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(open(pathname: *const c_char, flags: c_int, mode: mode_t) / { pathname: PathBuf, flags: c_int, mode: mode_t } -> RawFd
[INFO] [stdout] 555 ~     ~ [Desc, File] for [x86_64: 2, aarch64: 56, riscv64: 56, powerpc64: 5, s390x: 5)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:561:3
[INFO] [stdout]     |
[INFO] [stdout] 561 | /   open_tree(dirfd: RawFd, path: *const c_char, flags: c_uint) / { dirfd: RawFd, path: PathBuf, flags: c_uint } -> c_int
[INFO] [stdout] 562 | |     ~ [Desc, File] for [x86_64: 428, aarch64: 428, riscv64: 428, loongarch64: 428, powerpc64: 428, s390x: 428],
[INFO] [stdout]     | |_____________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 561 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(open_tree(dirfd: RawFd, path: *const c_char, flags: c_uint) / { dirfd: RawFd, path: PathBuf, flags: c_uint } -> c_int
[INFO] [stdout] 562 ~     ~ [Desc, File] for [x86_64: 428, aarch64: 428, riscv64: 428, loongarch64: 428, powerpc64: 428, s390x: 428)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:563:3
[INFO] [stdout]     |
[INFO] [stdout] 563 | /   open_tree_attr(dfd: RawFd, filename: *const c_char, flags: c_uint, uattr: *mut c_void, r#usize: size_t) /
[INFO] [stdout] 564 | |     { dfd: RawFd, filename: PathBuf, flags: c_uint, uattr: Arc<mount_attr> @ sized_by(raw_args.r#usize) } -> c_int
[INFO] [stdout] 565 | |     ~ [Desc, File] for [x86_64: 467, aarch64: 467, riscv64: 467, loongarch64: 467, powerpc64: 467, s390x: 467],
[INFO] [stdout]     | |_____________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 563 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(open_tree_attr(dfd: RawFd, filename: *const c_char, flags: c_uint, uattr: *mut c_void, r#usize: size_t) /
[INFO] [stdout] 564 |     { dfd: RawFd, filename: PathBuf, flags: c_uint, uattr: Arc<mount_attr> @ sized_by(raw_args.r#usize) } -> c_int
[INFO] [stdout] 565 ~     ~ [Desc, File] for [x86_64: 467, aarch64: 467, riscv64: 467, loongarch64: 467, powerpc64: 467, s390x: 467)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:566:3
[INFO] [stdout]     |
[INFO] [stdout] 566 | /   openat(dirfd: RawFd, pathname: *const c_char, flags: c_int, mode: mode_t) /
[INFO] [stdout] 567 | |     { dirfd: RawFd, pathname: PathBuf, flags: c_int, mode: mode_t } -> RawFd ~ [Desc, File] for [x86_64: 257, aarch64: 56, riscv64: 56, loongarch64: 56, powerpc64: 286, s390x: 288],
[INFO] [stdout]     | |___________________________________________________________________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 566 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(openat(dirfd: RawFd, pathname: *const c_char, flags: c_int, mode: mode_t) /
[INFO] [stdout] 567 ~     { dirfd: RawFd, pathname: PathBuf, flags: c_int, mode: mode_t } -> RawFd ~ [Desc, File] for [x86_64: 257, aarch64: 56, riscv64: 56, loongarch64: 56, powerpc64: 286, s390x: 288)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:568:3
[INFO] [stdout]     |
[INFO] [stdout] 568 | /   openat2(dirfd: RawFd, pathname: *const c_char, how: *mut open_how, size: size_t) /
[INFO] [stdout] 569 | |     { dirfd: RawFd, pathname: PathBuf, how: open_how, size: size_t } -> c_int ~ [Desc, File] for [x86_64: 437, aarch64: 437, riscv64: 437, loongarch64: 437, powerpc64: 437, s390x: 437],
[INFO] [stdout]     | |_______________________________________________________________________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 568 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(openat2(dirfd: RawFd, pathname: *const c_char, how: *mut open_how, size: size_t) /
[INFO] [stdout] 569 ~     { dirfd: RawFd, pathname: PathBuf, how: open_how, size: size_t } -> c_int ~ [Desc, File] for [x86_64: 437, aarch64: 437, riscv64: 437, loongarch64: 437, powerpc64: 437, s390x: 437)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:581:3
[INFO] [stdout]     |
[INFO] [stdout] 581 |   personality(persona: c_ulong) / { persona: c_ulong } -> c_int ~ [] for [x86_64: 135, aarch64: 92, riscv64: 92, loongarch64: 92, powerpc64: 136, s390x: 136],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 581 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(personality(persona: c_ulong) / { persona: c_ulong } -> c_int ~ [] for [x86_64: 135, aarch64: 92, riscv64: 92, loongarch64: 92, powerpc64: 136, s390x: 136)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                                          +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:585:3
[INFO] [stdout]     |
[INFO] [stdout] 585 | /   pidfd_send_signal(pidfd: RawFd, sig: c_int, info: *mut siginfo_t, flags: c_uint) /
[INFO] [stdout] 586 | |     { pidfd: RawFd, sig: c_int, info: Option<siginfo_t>, flags: c_uint } -> c_int
[INFO] [stdout] 587 | |     ~ [Desc, Signal, Process] for [x86_64: 424, aarch64: 424, riscv64: 424, loongarch64: 424, powerpc64: 424, s390x: 424],
[INFO] [stdout]     | |________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 585 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(pidfd_send_signal(pidfd: RawFd, sig: c_int, info: *mut siginfo_t, flags: c_uint) /
[INFO] [stdout] 586 |     { pidfd: RawFd, sig: c_int, info: Option<siginfo_t>, flags: c_uint } -> c_int
[INFO] [stdout] 587 ~     ~ [Desc, Signal, Process] for [x86_64: 424, aarch64: 424, riscv64: 424, loongarch64: 424, powerpc64: 424, s390x: 424)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:592:3
[INFO] [stdout]     |
[INFO] [stdout] 592 |   pkey_alloc(flags: c_uint, access_rights: c_uint) / { flags: c_uint, access_rights: c_uint } -> c_int ~ [] for [x86_64: 330, aarch64: 289, riscv64: 289, loongarch64: 289, powerpc64: 384, s390x: 385],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 592 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(pkey_alloc(flags: c_uint, access_rights: c_uint) / { flags: c_uint, access_rights: c_uint } -> c_int ~ [] for [x86_64: 330, aarch64: 289, riscv64: 289, loongarch64: 289, powerpc64: 384, s390x: 385)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                                                                                    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:593:3
[INFO] [stdout]     |
[INFO] [stdout] 593 |   pkey_free(pkey: c_int) / { pkey: c_int } -> c_int ~ [] for [x86_64: 331, aarch64: 290, riscv64: 290, loongarch64: 290, powerpc64: 385, s390x: 386],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 593 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(pkey_free(pkey: c_int) / { pkey: c_int } -> c_int ~ [] for [x86_64: 331, aarch64: 290, riscv64: 290, loongarch64: 290, powerpc64: 385, s390x: 386)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:613:3
[INFO] [stdout]     |
[INFO] [stdout] 613 | /   prlimit64(pid: pid_t, resource: c_int, new_limit: *const rlimit64, old_limit: *mut rlimit64) /
[INFO] [stdout] 614 | |     { pid: pid_t, resource: c_int, new_limit: Option<rlimit64>, old_limit: Option<rlimit64> } -> c_int + { old_limit: Option<rlim...
[INFO] [stdout] 615 | |     ~ [] for [x86_64: 302, aarch64: 261, riscv64: 261, loongarch64: 261, powerpc64: 325, s390x: 334],
[INFO] [stdout]     | |___________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 613 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(prlimit64(pid: pid_t, resource: c_int, new_limit: *const rlimit64, old_limit: *mut rlimit64) /
[INFO] [stdout] 614 |     { pid: pid_t, resource: c_int, new_limit: Option<rlimit64>, old_limit: Option<rlimit64> } -> c_int + { old_limit: Option<rlimit64> }
[INFO] [stdout] 615 ~     ~ [] for [x86_64: 302, aarch64: 261, riscv64: 261, loongarch64: 261, powerpc64: 325, s390x: 334)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:620:3
[INFO] [stdout]     |
[INFO] [stdout] 620 | /   process_vm_readv(pid: pid_t, local_iov: *const iovec, liovcnt: c_ulong, remote_iov: *const iovec, riovcnt: c_ulong, flags: c_ul...
[INFO] [stdout] 621 | |     { pid: pid_t, local_iov: Vec<iovec> @ counted_by(raw_args.liovcnt), remote_iov: Vec<iovec> @ counted_by(raw_args.riovcnt), fl...
[INFO] [stdout] 622 | |     -> ssize_t ~ [] for [x86_64: 310, aarch64: 270, riscv64: 270, loongarch64: 270, powerpc64: 351, s390x: 340],
[INFO] [stdout]     | |______________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 620 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(process_vm_readv(pid: pid_t, local_iov: *const iovec, liovcnt: c_ulong, remote_iov: *const iovec, riovcnt: c_ulong, flags: c_ulong) /
[INFO] [stdout] 621 |     { pid: pid_t, local_iov: Vec<iovec> @ counted_by(raw_args.liovcnt), remote_iov: Vec<iovec> @ counted_by(raw_args.riovcnt), flags: c_ulong }
[INFO] [stdout] 622 ~     -> ssize_t ~ [] for [x86_64: 310, aarch64: 270, riscv64: 270, loongarch64: 270, powerpc64: 351, s390x: 340)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:623:3
[INFO] [stdout]     |
[INFO] [stdout] 623 | /   process_vm_writev(pid: pid_t, local_iov: *const iovec, liovcnt: c_ulong, remote_iov: *const iovec, riovcnt: c_ulong, flags: c_u...
[INFO] [stdout] 624 | |     { pid: pid_t, local_iov: Vec<iovec> @ counted_by(raw_args.liovcnt), remote_iov: Vec<iovec> @ counted_by(raw_args.riovcnt), fl...
[INFO] [stdout] 625 | |     -> ssize_t ~ [] for [x86_64: 311, aarch64: 271, riscv64: 271, loongarch64: 271, powerpc64: 352, s390x: 341],
[INFO] [stdout]     | |______________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 623 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(process_vm_writev(pid: pid_t, local_iov: *const iovec, liovcnt: c_ulong, remote_iov: *const iovec, riovcnt: c_ulong, flags: c_ulong) /
[INFO] [stdout] 624 |     { pid: pid_t, local_iov: Vec<iovec> @ counted_by(raw_args.liovcnt), remote_iov: Vec<iovec> @ counted_by(raw_args.riovcnt), flags: c_ulong }
[INFO] [stdout] 625 ~     -> ssize_t ~ [] for [x86_64: 311, aarch64: 271, riscv64: 271, loongarch64: 271, powerpc64: 352, s390x: 341)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:632:3
[INFO] [stdout]     |
[INFO] [stdout] 632 | /   ptrace(request: c_int, pid: pid_t, addr: *mut c_void, data: *mut c_void) / { } -> c_long
[INFO] [stdout] 633 | |     ~ [] for [x86_64: 101, aarch64: 117, riscv64: 117, loongarch64: 117, powerpc64: 26, s390x: 26],
[INFO] [stdout]     | |_________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 632 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(ptrace(request: c_int, pid: pid_t, addr: *mut c_void, data: *mut c_void) / { } -> c_long
[INFO] [stdout] 633 ~     ~ [] for [x86_64: 101, aarch64: 117, riscv64: 117, loongarch64: 117, powerpc64: 26, s390x: 26)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:651:3
[INFO] [stdout]     |
[INFO] [stdout] 651 | /   readlinkat(dirfd: RawFd, pathname: *const c_char, buf: *mut c_char, bufsiz: size_t) /
[INFO] [stdout] 652 | |     { dirfd: RawFd, pathname: PathBuf, bufsiz: size_t } -> ssize_t + { buf: Vec<u8> @ counted_by(syscall_result) }
[INFO] [stdout] 653 | |     ~ [Desc, File] for [x86_64: 267, aarch64: 78, riscv64: 78, loongarch64: 78, powerpc64: 296, s390x: 298],
[INFO] [stdout]     | |__________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 651 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(readlinkat(dirfd: RawFd, pathname: *const c_char, buf: *mut c_char, bufsiz: size_t) /
[INFO] [stdout] 652 |     { dirfd: RawFd, pathname: PathBuf, bufsiz: size_t } -> ssize_t + { buf: Vec<u8> @ counted_by(syscall_result) }
[INFO] [stdout] 653 ~     ~ [Desc, File] for [x86_64: 267, aarch64: 78, riscv64: 78, loongarch64: 78, powerpc64: 296, s390x: 298)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:656:3
[INFO] [stdout]     |
[INFO] [stdout] 656 | /   reboot(magic: c_int, magic2: c_int, cmd: c_int, arg: *mut c_void) / { magic: c_int, magic2: c_int, cmd: c_int } -> c_int
[INFO] [stdout] 657 | |     ~ [] for [x86_64: 169, aarch64: 142, riscv64: 142, loongarch64: 142, powerpc64: 88, s390x: 88],
[INFO] [stdout]     | |_________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 656 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(reboot(magic: c_int, magic2: c_int, cmd: c_int, arg: *mut c_void) / { magic: c_int, magic2: c_int, cmd: c_int } -> c_int
[INFO] [stdout] 657 ~     ~ [] for [x86_64: 169, aarch64: 142, riscv64: 142, loongarch64: 142, powerpc64: 88, s390x: 88)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:673:3
[INFO] [stdout]     |
[INFO] [stdout] 673 | /   removexattrat(dfd: RawFd, pathname: *const c_char, at_flags: c_uint, name: *const c_char) /
[INFO] [stdout] 674 | |     { dfd: RawFd, pathname: PathBuf, at_flags: c_uint, name: CString } -> c_int
[INFO] [stdout] 675 | |     ~ [File, Desc] for [x86_64: 466, aarch64: 466, riscv64: 466, loongarch64: 466, powerpc64: 466, s390x: 466],
[INFO] [stdout]     | |_____________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 673 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(removexattrat(dfd: RawFd, pathname: *const c_char, at_flags: c_uint, name: *const c_char) /
[INFO] [stdout] 674 |     { dfd: RawFd, pathname: PathBuf, at_flags: c_uint, name: CString } -> c_int
[INFO] [stdout] 675 ~     ~ [File, Desc] for [x86_64: 466, aarch64: 466, riscv64: 466, loongarch64: 466, powerpc64: 466, s390x: 466)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:678:3
[INFO] [stdout]     |
[INFO] [stdout] 678 | /   renameat(olddirfd: RawFd, oldpath: *const c_char, newdirfd: RawFd, newpath: *const c_char) /
[INFO] [stdout] 679 | |     { olddirfd: RawFd, oldpath: PathBuf, newdirfd: RawFd, newpath: PathBuf } -> c_int
[INFO] [stdout] 680 | |     ~ [Desc, File] for [x86_64: 264, aarch64: 38, powerpc64: 293, s390x: 295],
[INFO] [stdout]     | |____________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 678 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(renameat(olddirfd: RawFd, oldpath: *const c_char, newdirfd: RawFd, newpath: *const c_char) /
[INFO] [stdout] 679 |     { olddirfd: RawFd, oldpath: PathBuf, newdirfd: RawFd, newpath: PathBuf } -> c_int
[INFO] [stdout] 680 ~     ~ [Desc, File] for [x86_64: 264, aarch64: 38, powerpc64: 293, s390x: 295)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:681:3
[INFO] [stdout]     |
[INFO] [stdout] 681 | /   renameat2(olddirfd: RawFd, oldpath: *const c_char, newdirfd: RawFd, newpath: *const c_char, flags: c_uint) /
[INFO] [stdout] 682 | |     { olddirfd: RawFd, oldpath: PathBuf, newdirfd: RawFd, newpath: PathBuf, flags: c_uint } -> c_int
[INFO] [stdout] 683 | |     ~ [Desc, File] for [x86_64: 316, aarch64: 276, riscv64: 276, loongarch64: 276, powerpc64: 357, s390x: 347],
[INFO] [stdout]     | |_____________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 681 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(renameat2(olddirfd: RawFd, oldpath: *const c_char, newdirfd: RawFd, newpath: *const c_char, flags: c_uint) /
[INFO] [stdout] 682 |     { olddirfd: RawFd, oldpath: PathBuf, newdirfd: RawFd, newpath: PathBuf, flags: c_uint } -> c_int
[INFO] [stdout] 683 ~     ~ [Desc, File] for [x86_64: 316, aarch64: 276, riscv64: 276, loongarch64: 276, powerpc64: 357, s390x: 347)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:684:3
[INFO] [stdout]     |
[INFO] [stdout] 684 | /   request_key(r#type: *const c_char, description: *const c_char, callout_info: *const c_char, dest_keyring: key_serial_t) /
[INFO] [stdout] 685 | |     { r#type: CString, description: CString, callout_info: Option<CString>, dest_keyring: key_serial_t } -> key_serial_t
[INFO] [stdout] 686 | |     ~ [] for [x86_64: 249, aarch64: 218, riscv64: 218, loongarch64: 218, powerpc64: 270, s390x: 279],
[INFO] [stdout]     | |___________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 684 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(request_key(r#type: *const c_char, description: *const c_char, callout_info: *const c_char, dest_keyring: key_serial_t) /
[INFO] [stdout] 685 |     { r#type: CString, description: CString, callout_info: Option<CString>, dest_keyring: key_serial_t } -> key_serial_t
[INFO] [stdout] 686 ~     ~ [] for [x86_64: 249, aarch64: 218, riscv64: 218, loongarch64: 218, powerpc64: 270, s390x: 279)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:687:3
[INFO] [stdout]     |
[INFO] [stdout] 687 |   restart_syscall() / {} -> c_long ~ [] for [x86_64: 219, aarch64: 128, riscv64: 128, loongarch64: 128, powerpc64: 0, s390x: 7],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 687 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(restart_syscall() / {} -> c_long ~ [] for [x86_64: 219, aarch64: 128, riscv64: 128, loongarch64: 128, powerpc64: 0, s390x: 7)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:698:3
[INFO] [stdout]     |
[INFO] [stdout] 698 | /   rseq(rseq: *mut c_void, rseq_len: u32, flags: c_int, sig: u32) / { rseq: Arc<rseq> @ sized_by(raw_args.rseq_len), flags: c_int,...
[INFO] [stdout] 699 | |     ~ [] for [x86_64: 334, aarch64: 293, riscv64: 293, loongarch64: 293, powerpc64: 387, s390x: 383],
[INFO] [stdout]     | |___________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 698 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(rseq(rseq: *mut c_void, rseq_len: u32, flags: c_int, sig: u32) / { rseq: Arc<rseq> @ sized_by(raw_args.rseq_len), flags: c_int, sig: u32 } -> c_int
[INFO] [stdout] 699 ~     ~ [] for [x86_64: 334, aarch64: 293, riscv64: 293, loongarch64: 293, powerpc64: 387, s390x: 383)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:700:3
[INFO] [stdout]     |
[INFO] [stdout] 700 |   rseq_slice_yield() / {} -> c_int ~ [] for [x86_64: 471, aarch64: 471, riscv64: 471, loongarch64: 471, powerpc64: 471, s390x: 471],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 700 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(rseq_slice_yield() / {} -> c_int ~ [] for [x86_64: 471, aarch64: 471, riscv64: 471, loongarch64: 471, powerpc64: 471, s390x: 471)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:709:3
[INFO] [stdout]     |
[INFO] [stdout] 709 | /   rt_sigqueueinfo(pid: pid_t, sig: c_int, info: *mut siginfo_t) / { pid: pid_t, sig: c_int, info: siginfo_t } -> c_int
[INFO] [stdout] 710 | |     ~ [Signal, Process] for [x86_64: 129, aarch64: 138, riscv64: 138, loongarch64: 138, powerpc64: 177, s390x: 178],
[INFO] [stdout]     | |__________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 709 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(rt_sigqueueinfo(pid: pid_t, sig: c_int, info: *mut siginfo_t) / { pid: pid_t, sig: c_int, info: siginfo_t } -> c_int
[INFO] [stdout] 710 ~     ~ [Signal, Process] for [x86_64: 129, aarch64: 138, riscv64: 138, loongarch64: 138, powerpc64: 177, s390x: 178)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:719:3
[INFO] [stdout]     |
[INFO] [stdout] 719 | /   rt_tgsigqueueinfo(tgid: pid_t, pid: pid_t, sig: c_int, info: *mut siginfo_t) /
[INFO] [stdout] 720 | |     { tgid: pid_t, pid: pid_t, sig: c_int, info: siginfo_t } -> c_int ~ [Signal, Process] for [x86_64: 297, aarch64: 240, riscv64: 240, loongarch64: 240, powerpc64: 322, s390x: 330],
[INFO] [stdout]     | |____________________________________________________________________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 719 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(rt_tgsigqueueinfo(tgid: pid_t, pid: pid_t, sig: c_int, info: *mut siginfo_t) /
[INFO] [stdout] 720 ~     { tgid: pid_t, pid: pid_t, sig: c_int, info: siginfo_t } -> c_int ~ [Signal, Process] for [x86_64: 297, aarch64: 240, riscv64: 240, loongarch64: 240, powerpc64: 322, s390x: 330)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:723:3
[INFO] [stdout]     |
[INFO] [stdout] 723 |   sched_get_priority_max(policy: c_int) / { policy: c_int } -> c_int ~ [] for [x86_64: 146, aarch64: 125, riscv64: 125, loongarch64: 125, powerpc64: 159, s390x: 159],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 723 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(sched_get_priority_max(policy: c_int) / { policy: c_int } -> c_int ~ [] for [x86_64: 146, aarch64: 125, riscv64: 125, loongarch64: 125, powerpc64: 159, s390x: 159)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                                                  +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:724:3
[INFO] [stdout]     |
[INFO] [stdout] 724 |   sched_get_priority_min(policy: c_int) / { policy: c_int } -> c_int ~ [] for [x86_64: 147, aarch64: 126, riscv64: 126, loongarch64: 126, powerpc64: 160, s390x: 160],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 724 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(sched_get_priority_min(policy: c_int) / { policy: c_int } -> c_int ~ [] for [x86_64: 147, aarch64: 126, riscv64: 126, loongarch64: 126, powerpc64: 160, s390x: 160)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                                                  +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:726:3
[INFO] [stdout]     |
[INFO] [stdout] 726 | /   sched_getaffinity(pid: pid_t, cpusetsize: size_t, mask: *mut c_ulong) /
[INFO] [stdout] 727 | |     { pid: pid_t, cpusetsize: size_t } -> c_int + { mask: Vec<u8> @ counted_by(syscall_result) }
[INFO] [stdout] 728 | |     ~ [] for [x86_64: 204, aarch64: 123, riscv64: 123, loongarch64: 123, powerpc64: 223, s390x: 240],
[INFO] [stdout]     | |___________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 726 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(sched_getaffinity(pid: pid_t, cpusetsize: size_t, mask: *mut c_ulong) /
[INFO] [stdout] 727 |     { pid: pid_t, cpusetsize: size_t } -> c_int + { mask: Vec<u8> @ counted_by(syscall_result) }
[INFO] [stdout] 728 ~     ~ [] for [x86_64: 204, aarch64: 123, riscv64: 123, loongarch64: 123, powerpc64: 223, s390x: 240)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:729:3
[INFO] [stdout]     |
[INFO] [stdout] 729 | /   sched_getattr(pid: pid_t, attr: *mut sched_attr, size: c_uint, flags: c_uint) /
[INFO] [stdout] 730 | |     { pid: pid_t, size: c_uint, flags: c_uint } -> c_int + { attr: sched_attr }
[INFO] [stdout] 731 | |     ~ [] for [x86_64: 315, aarch64: 275, riscv64: 275, loongarch64: 275, powerpc64: 356, s390x: 346],
[INFO] [stdout]     | |___________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 729 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(sched_getattr(pid: pid_t, attr: *mut sched_attr, size: c_uint, flags: c_uint) /
[INFO] [stdout] 730 |     { pid: pid_t, size: c_uint, flags: c_uint } -> c_int + { attr: sched_attr }
[INFO] [stdout] 731 ~     ~ [] for [x86_64: 315, aarch64: 275, riscv64: 275, loongarch64: 275, powerpc64: 356, s390x: 346)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:732:3
[INFO] [stdout]     |
[INFO] [stdout] 732 | /   sched_getparam(pid: pid_t, param: *mut sched_param) / { pid: pid_t } -> c_int + { param: sched_param }
[INFO] [stdout] 733 | |     ~ [] for [x86_64: 143, aarch64: 121, riscv64: 121, loongarch64: 121, powerpc64: 155, s390x: 155],
[INFO] [stdout]     | |___________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 732 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(sched_getparam(pid: pid_t, param: *mut sched_param) / { pid: pid_t } -> c_int + { param: sched_param }
[INFO] [stdout] 733 ~     ~ [] for [x86_64: 143, aarch64: 121, riscv64: 121, loongarch64: 121, powerpc64: 155, s390x: 155)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:734:3
[INFO] [stdout]     |
[INFO] [stdout] 734 |   sched_getscheduler(pid: pid_t) / { pid: pid_t } -> c_int ~ [] for [x86_64: 145, aarch64: 120, riscv64: 120, loongarch64: 120, powerpc64: 157, s390x: 157],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 734 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(sched_getscheduler(pid: pid_t) / { pid: pid_t } -> c_int ~ [] for [x86_64: 145, aarch64: 120, riscv64: 120, loongarch64: 120, powerpc64: 157, s390x: 157)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                                        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:735:3
[INFO] [stdout]     |
[INFO] [stdout] 735 | /   sched_rr_get_interval(pid: pid_t, tp: *mut timespec) / { pid: pid_t } -> c_int + { tp: timespec }
[INFO] [stdout] 736 | |     ~ [] for [x86_64: 148, aarch64: 127, riscv64: 127, loongarch64: 127, powerpc64: 161, s390x: 161],
[INFO] [stdout]     | |___________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 735 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(sched_rr_get_interval(pid: pid_t, tp: *mut timespec) / { pid: pid_t } -> c_int + { tp: timespec }
[INFO] [stdout] 736 ~     ~ [] for [x86_64: 148, aarch64: 127, riscv64: 127, loongarch64: 127, powerpc64: 161, s390x: 161)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:739:3
[INFO] [stdout]     |
[INFO] [stdout] 739 | /   sched_setaffinity(pid: pid_t, cpusetsize: size_t, mask: *const c_ulong) /
[INFO] [stdout] 740 | |     { pid: pid_t, cpusetsize: size_t, mask: Vec<u8> @ counted_by(cpusetsize) } -> c_int
[INFO] [stdout] 741 | |     ~ [] for [x86_64: 203, aarch64: 122, riscv64: 122, loongarch64: 122, powerpc64: 222, s390x: 239],
[INFO] [stdout]     | |___________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 739 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(sched_setaffinity(pid: pid_t, cpusetsize: size_t, mask: *const c_ulong) /
[INFO] [stdout] 740 |     { pid: pid_t, cpusetsize: size_t, mask: Vec<u8> @ counted_by(cpusetsize) } -> c_int
[INFO] [stdout] 741 ~     ~ [] for [x86_64: 203, aarch64: 122, riscv64: 122, loongarch64: 122, powerpc64: 222, s390x: 239)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:743:3
[INFO] [stdout]     |
[INFO] [stdout] 743 | /   sched_setattr(pid: pid_t, attr: *mut sched_attr, flags: c_uint) / { pid: pid_t, attr: sched_attr, flags: c_uint } -> c_int
[INFO] [stdout] 744 | |     ~ [] for [x86_64: 314, aarch64: 274, riscv64: 274, loongarch64: 274, powerpc64: 355, s390x: 345],
[INFO] [stdout]     | |___________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 743 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(sched_setattr(pid: pid_t, attr: *mut sched_attr, flags: c_uint) / { pid: pid_t, attr: sched_attr, flags: c_uint } -> c_int
[INFO] [stdout] 744 ~     ~ [] for [x86_64: 314, aarch64: 274, riscv64: 274, loongarch64: 274, powerpc64: 355, s390x: 345)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:745:3
[INFO] [stdout]     |
[INFO] [stdout] 745 | /   sched_setparam(pid: pid_t, param: *const sched_param) / { pid: pid_t, param: sched_param } -> c_int
[INFO] [stdout] 746 | |     ~ [] for [x86_64: 142, aarch64: 118, riscv64: 118, loongarch64: 118, powerpc64: 154, s390x: 154],
[INFO] [stdout]     | |___________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 745 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(sched_setparam(pid: pid_t, param: *const sched_param) / { pid: pid_t, param: sched_param } -> c_int
[INFO] [stdout] 746 ~     ~ [] for [x86_64: 142, aarch64: 118, riscv64: 118, loongarch64: 118, powerpc64: 154, s390x: 154)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:747:3
[INFO] [stdout]     |
[INFO] [stdout] 747 | /   sched_setscheduler(pid: pid_t, policy: c_int, param: *const sched_param) /
[INFO] [stdout] 748 | |     { pid: pid_t, policy: c_int, param: sched_param } -> c_int
[INFO] [stdout] 749 | |     ~ [] for [x86_64: 144, aarch64: 119, riscv64: 119, loongarch64: 119, powerpc64: 156, s390x: 156],
[INFO] [stdout]     | |___________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 747 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(sched_setscheduler(pid: pid_t, policy: c_int, param: *const sched_param) /
[INFO] [stdout] 748 |     { pid: pid_t, policy: c_int, param: sched_param } -> c_int
[INFO] [stdout] 749 ~     ~ [] for [x86_64: 144, aarch64: 119, riscv64: 119, loongarch64: 119, powerpc64: 156, s390x: 156)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:750:3
[INFO] [stdout]     |
[INFO] [stdout] 750 |   sched_yield() / {} -> c_int ~ [] for [x86_64: 24, aarch64: 124, riscv64: 124, loongarch64: 124, powerpc64: 158, s390x: 158],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 750 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(sched_yield() / {} -> c_int ~ [] for [x86_64: 24, aarch64: 124, riscv64: 124, loongarch64: 124, powerpc64: 158, s390x: 158)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                          +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:752:3
[INFO] [stdout]     |
[INFO] [stdout] 752 | /   seccomp(operation: c_int, flags: c_uint, args: *mut c_void) / { operation: c_int, flags: c_uint } -> c_int
[INFO] [stdout] 753 | |     ~ [] for [x86_64: 317, aarch64: 277, riscv64: 277, loongarch64: 277, powerpc64: 358, s390x: 348],
[INFO] [stdout]     | |___________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 752 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(seccomp(operation: c_int, flags: c_uint, args: *mut c_void) / { operation: c_int, flags: c_uint } -> c_int
[INFO] [stdout] 753 ~     ~ [] for [x86_64: 317, aarch64: 277, riscv64: 277, loongarch64: 277, powerpc64: 358, s390x: 348)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:770:3
[INFO] [stdout]     |
[INFO] [stdout] 770 | /   sendfile(out_fd: RawFd, in_fd: RawFd, offset: *mut off_t, count: size_t) /
[INFO] [stdout] 771 | |     { out_fd: RawFd, in_fd: RawFd, offset: off_t, count: size_t } -> ssize_t ~ [Desc, Network] for [x86_64: 40, aarch64: 71, riscv64: 71, loongarch64: 71, powerpc64: 186, s390x: 187],
[INFO] [stdout]     | |_____________________________________________________________________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 770 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(sendfile(out_fd: RawFd, in_fd: RawFd, offset: *mut off_t, count: size_t) /
[INFO] [stdout] 771 ~     { out_fd: RawFd, in_fd: RawFd, offset: off_t, count: size_t } -> ssize_t ~ [Desc, Network] for [x86_64: 40, aarch64: 71, riscv64: 71, loongarch64: 71, powerpc64: 186, s390x: 187)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:789:3
[INFO] [stdout]     |
[INFO] [stdout] 789 | /   set_robust_list(head: *mut robust_list_head, len: size_t) / { head: AddressType, len: size_t } -> c_long
[INFO] [stdout] 790 | |     ~ [] for [x86_64: 273, aarch64: 99, riscv64: 99, loongarch64: 99, powerpc64: 300, s390x: 304],
[INFO] [stdout]     | |________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 789 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(set_robust_list(head: *mut robust_list_head, len: size_t) / { head: AddressType, len: size_t } -> c_long
[INFO] [stdout] 790 ~     ~ [] for [x86_64: 273, aarch64: 99, riscv64: 99, loongarch64: 99, powerpc64: 300, s390x: 304)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:791:3
[INFO] [stdout]     |
[INFO] [stdout] 791 |   set_thread_area(u_info: *mut user_desc) / { u_info: user_desc } -> c_int ~ [] for [x86_64: 205],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 791 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(set_thread_area(u_info: *mut user_desc) / { u_info: user_desc } -> c_int ~ [] for [x86_64: 205)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                              +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:792:3
[INFO] [stdout]     |
[INFO] [stdout] 792 |   set_tid_address(tidptr: *mut c_int) / { tidptr: AddressType } -> pid_t ~ [] for [x86_64: 218, aarch64: 96, riscv64: 96, loongarch64: 96, powerpc64: 232, s390x: 252],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 792 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(set_tid_address(tidptr: *mut c_int) / { tidptr: AddressType } -> pid_t ~ [] for [x86_64: 218, aarch64: 96, riscv64: 96, loongarch64: 96, powerpc64: 232, s390x: 252)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                                                   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:794:3
[INFO] [stdout]     |
[INFO] [stdout] 794 |   setdomainname(name: *const c_char, len: size_t) / { name: CString } -> c_int ~ [] for [x86_64: 171, aarch64: 162, riscv64: 162, loongarch64: 162, powerpc64: 121, s390x: 121],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 794 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(setdomainname(name: *const c_char, len: size_t) / { name: CString } -> c_int ~ [] for [x86_64: 171, aarch64: 162, riscv64: 162, loongarch64: 162, powerpc64: 121, s390x: 121)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                                                            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:806:3
[INFO] [stdout]     |
[INFO] [stdout] 806 | /   sethostname(name: *const c_char, len: size_t) / { name: CString, len: size_t } -> c_int
[INFO] [stdout] 807 | |     ~ [] for [x86_64: 170, aarch64: 161, riscv64: 161, loongarch64: 161, powerpc64: 74, s390x: 74],
[INFO] [stdout]     | |_________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 806 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(sethostname(name: *const c_char, len: size_t) / { name: CString, len: size_t } -> c_int
[INFO] [stdout] 807 ~     ~ [] for [x86_64: 170, aarch64: 161, riscv64: 161, loongarch64: 161, powerpc64: 74, s390x: 74)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:808:3
[INFO] [stdout]     |
[INFO] [stdout] 808 | /   setitimer(which: c_int, new_value: *const itimerval, old_value: *mut itimerval) /
[INFO] [stdout] 809 | |     { which: c_int, new_value: itimerval, old_value: Option<itimerval> } -> c_int
[INFO] [stdout] 810 | |     ~ [] for [x86_64: 38, aarch64: 103, riscv64: 103, loongarch64: 103, powerpc64: 104, s390x: 104],
[INFO] [stdout]     | |__________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 808 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(setitimer(which: c_int, new_value: *const itimerval, old_value: *mut itimerval) /
[INFO] [stdout] 809 |     { which: c_int, new_value: itimerval, old_value: Option<itimerval> } -> c_int
[INFO] [stdout] 810 ~     ~ [] for [x86_64: 38, aarch64: 103, riscv64: 103, loongarch64: 103, powerpc64: 104, s390x: 104)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:812:3
[INFO] [stdout]     |
[INFO] [stdout] 812 |   setpgid(pid: pid_t, pgid: pid_t) / { pid: pid_t, pgid: pid_t } -> c_int ~ [] for [x86_64: 109, aarch64: 154, riscv64: 154, loongarch64: 154, powerpc64: 57, s390x: 57],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 812 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(setpgid(pid: pid_t, pgid: pid_t) / { pid: pid_t, pgid: pid_t } -> c_int ~ [] for [x86_64: 109, aarch64: 154, riscv64: 154, loongarch64: 154, powerpc64: 57, s390x: 57)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                                                     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:814:3
[INFO] [stdout]     |
[INFO] [stdout] 814 | /   setpriority(which: c_int, who: id_t, prio: c_int) / { which: c_int, who: id_t, prio: c_int } -> c_int
[INFO] [stdout] 815 | |     ~ [] for [x86_64: 141, aarch64: 140, riscv64: 140, loongarch64: 140, powerpc64: 97, s390x: 97],
[INFO] [stdout]     | |_________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 814 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(setpriority(which: c_int, who: id_t, prio: c_int) / { which: c_int, who: id_t, prio: c_int } -> c_int
[INFO] [stdout] 815 ~     ~ [] for [x86_64: 141, aarch64: 140, riscv64: 140, loongarch64: 140, powerpc64: 97, s390x: 97)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:826:3
[INFO] [stdout]     |
[INFO] [stdout] 826 | /   setrlimit(resource: c_int, rlim: *const rlimit) / { resource: c_int, rlim: rlimit } -> c_int
[INFO] [stdout] 827 | |     ~ [] for [x86_64: 160, aarch64: 164, riscv64: 164, powerpc64: 75, s390x: 75],
[INFO] [stdout]     | |_______________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 826 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(setrlimit(resource: c_int, rlim: *const rlimit) / { resource: c_int, rlim: rlimit } -> c_int
[INFO] [stdout] 827 ~     ~ [] for [x86_64: 160, aarch64: 164, riscv64: 164, powerpc64: 75, s390x: 75)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:828:3
[INFO] [stdout]     |
[INFO] [stdout] 828 |   setsid() / {} -> pid_t ~ [] for [x86_64: 112, aarch64: 157, riscv64: 157, loongarch64: 157, powerpc64: 66, s390x: 66],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 828 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(setsid() / {} -> pid_t ~ [] for [x86_64: 112, aarch64: 157, riscv64: 157, loongarch64: 157, powerpc64: 66, s390x: 66)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:839:3
[INFO] [stdout]     |
[INFO] [stdout] 839 | /   setxattrat(dfd: RawFd, pathname: *const c_char, at_flags: c_uint, name: *const c_char, uargs: *const c_void, r#usize: size_t) /
[INFO] [stdout] 840 | |     { dfd: RawFd, pathname: PathBuf, at_flags: c_uint, name: CString, uargs: Arc<xattr_args> @ sized_by(raw_args.r#usize) } -> c_int
[INFO] [stdout] 841 | |     ~ [File, Desc] for [x86_64: 463, aarch64: 463, riscv64: 463, loongarch64: 463, powerpc64: 463, s390x: 463],
[INFO] [stdout]     | |_____________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 839 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(setxattrat(dfd: RawFd, pathname: *const c_char, at_flags: c_uint, name: *const c_char, uargs: *const c_void, r#usize: size_t) /
[INFO] [stdout] 840 |     { dfd: RawFd, pathname: PathBuf, at_flags: c_uint, name: CString, uargs: Arc<xattr_args> @ sized_by(raw_args.r#usize) } -> c_int
[INFO] [stdout] 841 ~     ~ [File, Desc] for [x86_64: 463, aarch64: 463, riscv64: 463, loongarch64: 463, powerpc64: 463, s390x: 463)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:843:3
[INFO] [stdout]     |
[INFO] [stdout] 843 | /   shmat(shmid: c_int, shmaddr: *const c_void, shmflg: c_int) / { shmid: c_int, shmaddr: AddressType, shmflg: c_int } -> AddressType
[INFO] [stdout] 844 | |     ~ [IPC, Memory] for [x86_64: 30, aarch64: 196, riscv64: 196, loongarch64: 196, powerpc64: 397, s390x: 397],
[INFO] [stdout]     | |_____________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 843 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(shmat(shmid: c_int, shmaddr: *const c_void, shmflg: c_int) / { shmid: c_int, shmaddr: AddressType, shmflg: c_int } -> AddressType
[INFO] [stdout] 844 ~     ~ [IPC, Memory] for [x86_64: 30, aarch64: 196, riscv64: 196, loongarch64: 196, powerpc64: 397, s390x: 397)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:847:3
[INFO] [stdout]     |
[INFO] [stdout] 847 |   shmdt(shmaddr: *const c_void) / { shmaddr: AddressType } -> c_int ~ [IPC, Memory] for [x86_64: 67, aarch64: 197, riscv64: 197, loongarch64: 197, powerpc64: 398, s390x: 398],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 847 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(shmdt(shmaddr: *const c_void) / { shmaddr: AddressType } -> c_int ~ [IPC, Memory] for [x86_64: 67, aarch64: 197, riscv64: 197, loongarch64: 197, powerpc64: 398, s390x: 398)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                                                           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:855:3
[INFO] [stdout]     |
[INFO] [stdout] 855 | /   signalfd(fd: RawFd, mask: *const sigset_t, size: size_t) / { fd: RawFd, mask: sigset_t, size: size_t } -> c_int
[INFO] [stdout] 856 | |     ~ [Desc, Signal] for [x86_64: 282, powerpc64: 305, s390x: 316],
[INFO] [stdout]     | |_________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 855 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(signalfd(fd: RawFd, mask: *const sigset_t, size: size_t) / { fd: RawFd, mask: sigset_t, size: size_t } -> c_int
[INFO] [stdout] 856 ~     ~ [Desc, Signal] for [x86_64: 282, powerpc64: 305, s390x: 316)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:857:3
[INFO] [stdout]     |
[INFO] [stdout] 857 | /   signalfd4(fd: RawFd, mask: *const sigset_t, size: size_t, flags: c_int) / { fd: RawFd, mask: sigset_t, size: size_t, flags: c_i...
[INFO] [stdout] 858 | |     ~ [Desc, Signal] for [x86_64: 289, aarch64: 74, riscv64: 74, loongarch64: 74, powerpc64: 313, s390x: 322],
[INFO] [stdout]     | |____________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 857 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(signalfd4(fd: RawFd, mask: *const sigset_t, size: size_t, flags: c_int) / { fd: RawFd, mask: sigset_t, size: size_t, flags: c_int } -> c_int
[INFO] [stdout] 858 ~     ~ [Desc, Signal] for [x86_64: 289, aarch64: 74, riscv64: 74, loongarch64: 74, powerpc64: 313, s390x: 322)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:875:3
[INFO] [stdout]     |
[INFO] [stdout] 875 | /   stat(pathname: *const c_char, statbuf: *mut stat) / { pathname: PathBuf } -> c_int + { statbuf: stat }
[INFO] [stdout] 876 | |     ~ [File, Stat, StatLike] for [x86_64: 4, powerpc64: 106, s390x: 106],
[INFO] [stdout]     | |_______________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 875 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(stat(pathname: *const c_char, statbuf: *mut stat) / { pathname: PathBuf } -> c_int + { statbuf: stat }
[INFO] [stdout] 876 ~     ~ [File, Stat, StatLike] for [x86_64: 4, powerpc64: 106, s390x: 106)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:878:3
[INFO] [stdout]     |
[INFO] [stdout] 878 | /   statfs(path: *const c_char, buf: *mut statfs) / { path: PathBuf } -> c_int + { buf: statfs }
[INFO] [stdout] 879 | |     ~ [File, StatFs, StatFsLike] for [x86_64: 137, aarch64: 43, riscv64: 43, loongarch64: 43, powerpc64: 99, s390x: 99],
[INFO] [stdout]     | |______________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 878 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(statfs(path: *const c_char, buf: *mut statfs) / { path: PathBuf } -> c_int + { buf: statfs }
[INFO] [stdout] 879 ~     ~ [File, StatFs, StatFsLike] for [x86_64: 137, aarch64: 43, riscv64: 43, loongarch64: 43, powerpc64: 99, s390x: 99)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:882:3
[INFO] [stdout]     |
[INFO] [stdout] 882 | /   statmount(req: *const mnt_id_req, buf: *mut c_void, bufsize: size_t, flags: c_uint) /
[INFO] [stdout] 883 | |     { req: mnt_id_req, bufsize: size_t, flags: c_uint } -> c_int + { buf: Arc<statmount> @ sized_by(raw_args.bufsize) }
[INFO] [stdout] 884 | |     ~ [] for [x86_64: 457, aarch64: 457, riscv64: 457, loongarch64: 457, powerpc64: 457, s390x: 457],
[INFO] [stdout]     | |___________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 882 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(statmount(req: *const mnt_id_req, buf: *mut c_void, bufsize: size_t, flags: c_uint) /
[INFO] [stdout] 883 |     { req: mnt_id_req, bufsize: size_t, flags: c_uint } -> c_int + { buf: Arc<statmount> @ sized_by(raw_args.bufsize) }
[INFO] [stdout] 884 ~     ~ [] for [x86_64: 457, aarch64: 457, riscv64: 457, loongarch64: 457, powerpc64: 457, s390x: 457)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:885:3
[INFO] [stdout]     |
[INFO] [stdout] 885 | /   statx(dirfd: RawFd, pathname: *const c_char, flags: c_int, mask: c_uint, statxbuf: *mut statx) /
[INFO] [stdout] 886 | |     { dirfd: RawFd, pathname: PathBuf, flags: c_int, mask: c_uint } -> c_int + { statxbuf: statx }
[INFO] [stdout] 887 | |     ~ [Desc, File, FStat, StatLike] for [x86_64: 332, aarch64: 291, riscv64: 291, loongarch64: 291, powerpc64: 383, s390x: 379],
[INFO] [stdout]     | |______________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 885 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(statx(dirfd: RawFd, pathname: *const c_char, flags: c_int, mask: c_uint, statxbuf: *mut statx) /
[INFO] [stdout] 886 |     { dirfd: RawFd, pathname: PathBuf, flags: c_int, mask: c_uint } -> c_int + { statxbuf: statx }
[INFO] [stdout] 887 ~     ~ [Desc, File, FStat, StatLike] for [x86_64: 332, aarch64: 291, riscv64: 291, loongarch64: 291, powerpc64: 383, s390x: 379)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:897:3
[INFO] [stdout]     |
[INFO] [stdout] 897 | /   symlinkat(target: *const c_char, newdirfd: RawFd, linkpath: *const c_char) /
[INFO] [stdout] 898 | |     { target: PathBuf, newdirfd: RawFd, linkpath: PathBuf } -> c_int
[INFO] [stdout] 899 | |     ~ [Desc, File] for [x86_64: 266, aarch64: 36, riscv64: 36, loongarch64: 36, powerpc64: 295, s390x: 297],
[INFO] [stdout]     | |__________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 897 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(symlinkat(target: *const c_char, newdirfd: RawFd, linkpath: *const c_char) /
[INFO] [stdout] 898 |     { target: PathBuf, newdirfd: RawFd, linkpath: PathBuf } -> c_int
[INFO] [stdout] 899 ~     ~ [Desc, File] for [x86_64: 266, aarch64: 36, riscv64: 36, loongarch64: 36, powerpc64: 295, s390x: 297)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:901:3
[INFO] [stdout]     |
[INFO] [stdout] 901 |   sync() / {} -> c_int ~ [] for [x86_64: 162, aarch64: 81, riscv64: 81, loongarch64: 81, powerpc64: 36, s390x: 36],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 901 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(sync() / {} -> c_int ~ [] for [x86_64: 162, aarch64: 81, riscv64: 81, loongarch64: 81, powerpc64: 36, s390x: 36)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                               +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:909:3
[INFO] [stdout]     |
[INFO] [stdout] 909 | /   sysfs(option: c_int, arg1: c_ulong, arg2: c_ulong) / { option: c_int, arg1: c_ulong, arg2: c_ulong } -> c_int
[INFO] [stdout] 910 | |     ~ [] for [x86_64: 139, powerpc64: 135, s390x: 135],
[INFO] [stdout]     | |_____________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 909 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(sysfs(option: c_int, arg1: c_ulong, arg2: c_ulong) / { option: c_int, arg1: c_ulong, arg2: c_ulong } -> c_int
[INFO] [stdout] 910 ~     ~ [] for [x86_64: 139, powerpc64: 135, s390x: 135)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:911:3
[INFO] [stdout]     |
[INFO] [stdout] 911 |   sysinfo(info: *mut sysinfo) / { } -> c_int + { info: sysinfo } ~ [] for [x86_64: 99, aarch64: 179, riscv64: 179, loongarch64: 179, powerpc64: 116, s390x: 116],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 911 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(sysinfo(info: *mut sysinfo) / { } -> c_int + { info: sysinfo } ~ [] for [x86_64: 99, aarch64: 179, riscv64: 179, loongarch64: 179, powerpc64: 116, s390x: 116)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                                             +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:912:3
[INFO] [stdout]     |
[INFO] [stdout] 912 | /   syslog(typ: c_int, buf: *const c_char, len: c_int) / { typ: c_int, buf: CString, len: c_int } -> c_int
[INFO] [stdout] 913 | |     ~ [] for [x86_64: 103, aarch64: 116, riscv64: 116, loongarch64: 116, powerpc64: 103, s390x: 103],
[INFO] [stdout]     | |___________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 912 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(syslog(typ: c_int, buf: *const c_char, len: c_int) / { typ: c_int, buf: CString, len: c_int } -> c_int
[INFO] [stdout] 913 ~     ~ [] for [x86_64: 103, aarch64: 116, riscv64: 116, loongarch64: 116, powerpc64: 103, s390x: 103)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:917:3
[INFO] [stdout]     |
[INFO] [stdout] 917 | /   tgkill(tgid: pid_t, tid: pid_t, sig: c_int) / { tgid: pid_t, tid: pid_t, sig: c_int } -> c_int
[INFO] [stdout] 918 | |     ~ [Signal, Process] for [x86_64: 234, aarch64: 131, riscv64: 131, loongarch64: 131, powerpc64: 250, s390x: 241],
[INFO] [stdout]     | |__________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 917 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(tgkill(tgid: pid_t, tid: pid_t, sig: c_int) / { tgid: pid_t, tid: pid_t, sig: c_int } -> c_int
[INFO] [stdout] 918 ~     ~ [Signal, Process] for [x86_64: 234, aarch64: 131, riscv64: 131, loongarch64: 131, powerpc64: 250, s390x: 241)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:920:3
[INFO] [stdout]     |
[INFO] [stdout] 920 | /   timer_create(clockid: clockid_t, sevp: *const sigevent, timerid: *mut timer_t) /
[INFO] [stdout] 921 | |     { clockid: clockid_t, sevp: Option<sigevent> } -> c_int + { timerid: InspectResult<timer_t> }
[INFO] [stdout] 922 | |     ~ [] for [x86_64: 222, aarch64: 107, riscv64: 107, loongarch64: 107, powerpc64: 240, s390x: 254],
[INFO] [stdout]     | |___________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 920 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(timer_create(clockid: clockid_t, sevp: *const sigevent, timerid: *mut timer_t) /
[INFO] [stdout] 921 |     { clockid: clockid_t, sevp: Option<sigevent> } -> c_int + { timerid: InspectResult<timer_t> }
[INFO] [stdout] 922 ~     ~ [] for [x86_64: 222, aarch64: 107, riscv64: 107, loongarch64: 107, powerpc64: 240, s390x: 254)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:923:3
[INFO] [stdout]     |
[INFO] [stdout] 923 |   timer_delete(timerid: timer_t) / { timerid: timer_t } -> c_int ~ [] for [x86_64: 226, aarch64: 111, riscv64: 111, loongarch64: 111, powerpc64: 244, s390x: 258],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 923 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(timer_delete(timerid: timer_t) / { timerid: timer_t } -> c_int ~ [] for [x86_64: 226, aarch64: 111, riscv64: 111, loongarch64: 111, powerpc64: 244, s390x: 258)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                                              +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:924:3
[INFO] [stdout]     |
[INFO] [stdout] 924 |   timer_getoverrun(timerid: timer_t) / { timerid: timer_t } -> c_int ~ [] for [x86_64: 225, aarch64: 109, riscv64: 109, loongarch64: 109, powerpc64: 243, s390x: 257],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 924 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(timer_getoverrun(timerid: timer_t) / { timerid: timer_t } -> c_int ~ [] for [x86_64: 225, aarch64: 109, riscv64: 109, loongarch64: 109, powerpc64: 243, s390x: 257)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                                                  +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:925:3
[INFO] [stdout]     |
[INFO] [stdout] 925 | /   timer_gettime(timerid: timer_t, curr_value: *mut itimerspec) / { timerid: timer_t } -> c_int + { curr_value: itimerspec }
[INFO] [stdout] 926 | |     ~ [] for [x86_64: 224, aarch64: 108, riscv64: 108, loongarch64: 108, powerpc64: 242, s390x: 256],
[INFO] [stdout]     | |___________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 925 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(timer_gettime(timerid: timer_t, curr_value: *mut itimerspec) / { timerid: timer_t } -> c_int + { curr_value: itimerspec }
[INFO] [stdout] 926 ~     ~ [] for [x86_64: 224, aarch64: 108, riscv64: 108, loongarch64: 108, powerpc64: 242, s390x: 256)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:928:3
[INFO] [stdout]     |
[INFO] [stdout] 928 | /   timer_settime(timerid: timer_t, flags: c_int, new_value: *const itimerspec, old_value: *mut itimerspec) /
[INFO] [stdout] 929 | |     { timerid: timer_t, flags: c_int, new_value: itimerspec } -> c_int + { old_value: Option<itimerspec> }
[INFO] [stdout] 930 | |     ~ [] for [x86_64: 223, aarch64: 110, riscv64: 110, loongarch64: 110, powerpc64: 241, s390x: 255],
[INFO] [stdout]     | |___________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 928 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(timer_settime(timerid: timer_t, flags: c_int, new_value: *const itimerspec, old_value: *mut itimerspec) /
[INFO] [stdout] 929 |     { timerid: timer_t, flags: c_int, new_value: itimerspec } -> c_int + { old_value: Option<itimerspec> }
[INFO] [stdout] 930 ~     ~ [] for [x86_64: 223, aarch64: 110, riscv64: 110, loongarch64: 110, powerpc64: 241, s390x: 255)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:942:3
[INFO] [stdout]     |
[INFO] [stdout] 942 |   times(buf: *mut tms) / { } -> clock_t + { buf: tms } ~ [] for [x86_64: 100, aarch64: 153, riscv64: 153, loongarch64: 153, powerpc64: 43, s390x: 43],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 942 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(times(buf: *mut tms) / { } -> clock_t + { buf: tms } ~ [] for [x86_64: 100, aarch64: 153, riscv64: 153, loongarch64: 153, powerpc64: 43, s390x: 43)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                                  +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:943:3
[INFO] [stdout]     |
[INFO] [stdout] 943 |   tkill(tid: pid_t, sig: c_int) / { tid: pid_t, sig: c_int } -> c_int ~ [Signal, Process] for [x86_64: 200, aarch64: 130, riscv64: 130, loongarch64: 130, powerpc64: 208, s390x: 237],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 943 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(tkill(tid: pid_t, sig: c_int) / { tid: pid_t, sig: c_int } -> c_int ~ [Signal, Process] for [x86_64: 200, aarch64: 130, riscv64: 130, loongarch64: 130, powerpc64: 208, s390x: 237)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                                                                  +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:948:3
[INFO] [stdout]     |
[INFO] [stdout] 948 |   umask(mask: mode_t) / { mask: mode_t } -> mode_t ~ [] for [x86_64: 95, aarch64: 166, riscv64: 166, loongarch64: 166, powerpc64: 60, s390x: 60],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 948 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(umask(mask: mode_t) / { mask: mode_t } -> mode_t ~ [] for [x86_64: 95, aarch64: 166, riscv64: 166, loongarch64: 166, powerpc64: 60, s390x: 60)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                             +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:952:3
[INFO] [stdout]     |
[INFO] [stdout] 952 |   uname(buf: *mut utsname) / { } -> c_int + { buf: utsname } ~ [] for [x86_64: 63, aarch64: 160, riscv64: 160, loongarch64: 160, powerpc64: 122, s390x: 122],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 952 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(uname(buf: *mut utsname) / { } -> c_int + { buf: utsname } ~ [] for [x86_64: 63, aarch64: 160, riscv64: 160, loongarch64: 160, powerpc64: 122, s390x: 122)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                                         +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:954:3
[INFO] [stdout]     |
[INFO] [stdout] 954 | /   unlinkat(dirfd: RawFd, pathname: *const c_char, flags: c_int) / { dirfd: RawFd, pathname: PathBuf, flags: c_int } -> c_int
[INFO] [stdout] 955 | |     ~ [Desc, File] for [x86_64: 263, aarch64: 35, riscv64: 35, loongarch64: 35, powerpc64: 292, s390x: 294],
[INFO] [stdout]     | |__________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 954 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(unlinkat(dirfd: RawFd, pathname: *const c_char, flags: c_int) / { dirfd: RawFd, pathname: PathBuf, flags: c_int } -> c_int
[INFO] [stdout] 955 ~     ~ [Desc, File] for [x86_64: 263, aarch64: 35, riscv64: 35, loongarch64: 35, powerpc64: 292, s390x: 294)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:956:3
[INFO] [stdout]     |
[INFO] [stdout] 956 |   unshare(flags: c_int) / { flags: c_int } -> c_int ~ [] for [x86_64: 272, aarch64: 97, riscv64: 97, loongarch64: 97, powerpc64: 282, s390x: 303],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 956 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(unshare(flags: c_int) / { flags: c_int } -> c_int ~ [] for [x86_64: 272, aarch64: 97, riscv64: 97, loongarch64: 97, powerpc64: 282, s390x: 303)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                              +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:957:3
[INFO] [stdout]     |
[INFO] [stdout] 957 |   uprobe() / {} -> c_int ~ [] for [x86_64: 336],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 957 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(uprobe() / {} -> c_int ~ [] for [x86_64: 336)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:958:3
[INFO] [stdout]     |
[INFO] [stdout] 958 |   uretprobe() / { } -> c_int ~ [] for [x86_64: 335],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 958 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(uretprobe() / { } -> c_int ~ [] for [x86_64: 335)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:960:3
[INFO] [stdout]     |
[INFO] [stdout] 960 |   ustat(dev: dev_t, ubuf: *mut ustat) / { dev: dev_t } -> c_int + { ubuf: ustat } ~ [] for [x86_64: 136, powerpc64: 62, s390x: 62],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 960 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(ustat(dev: dev_t, ubuf: *mut ustat) / { dev: dev_t } -> c_int + { ubuf: ustat } ~ [] for [x86_64: 136, powerpc64: 62, s390x: 62)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                               +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:963:3
[INFO] [stdout]     |
[INFO] [stdout] 963 | /   utimensat(dirfd: RawFd, pathname: *const c_char, times: *const timespec, flags: c_int) /
[INFO] [stdout] 964 | |     { dirfd: RawFd, pathname: PathBuf, times: Option<[timespec; 2]>, flags: c_int } -> c_int
[INFO] [stdout] 965 | |     ~ [Desc, File] for [x86_64: 280, aarch64: 88, riscv64: 88, loongarch64: 88, powerpc64: 304, s390x: 315],
[INFO] [stdout]     | |__________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 963 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(utimensat(dirfd: RawFd, pathname: *const c_char, times: *const timespec, flags: c_int) /
[INFO] [stdout] 964 |     { dirfd: RawFd, pathname: PathBuf, times: Option<[timespec; 2]>, flags: c_int } -> c_int
[INFO] [stdout] 965 ~     ~ [Desc, File] for [x86_64: 280, aarch64: 88, riscv64: 88, loongarch64: 88, powerpc64: 304, s390x: 315)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:971:3
[INFO] [stdout]     |
[INFO] [stdout] 971 |   vhangup() / {} -> c_int ~ [] for [x86_64: 153, aarch64: 58, riscv64: 58, loongarch64: 58, powerpc64: 111, s390x: 111],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 971 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(vhangup() / {} -> c_int ~ [] for [x86_64: 153, aarch64: 58, riscv64: 58, loongarch64: 58, powerpc64: 111, s390x: 111)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] warning: function `read_lossy_string` is never used
[INFO] [stdout]    --> src/inspect.rs:340:4
[INFO] [stdout]     |
[INFO] [stdout] 340 | fn read_lossy_string(pid: Pid, address: AddressType) -> InspectResult<String> {
[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: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]   --> src/syscalls.rs:87:3
[INFO] [stdout]    |
[INFO] [stdout] 87 | /   add_key(r#type: *const c_char, description: *const c_char, payload: *const c_void, plen: size_t, keyring: key_serial_t ) /
[INFO] [stdout] 88 | |     { r#type: CString, description: CString, payload: Vec<u8> @ counted_by(raw_args.plen), keyring: key_serial_t }
[INFO] [stdout] 89 | |     -> key_serial_t ~ [] for [x86_64: 248, aarch64: 217, riscv64: 217, loongarch64: 217, powerpc64: 269, s390x: 278],
[INFO] [stdout]    | |___________________________________________________________________________________________________________________^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout]    = note: `#[deny(self_type_conversion)]` on by default
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 87 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(add_key(r#type: *const c_char, description: *const c_char, payload: *const c_void, plen: size_t, keyring: key_serial_t ) /
[INFO] [stdout] 88 |     { r#type: CString, description: CString, payload: Vec<u8> @ counted_by(raw_args.plen), keyring: key_serial_t }
[INFO] [stdout] 89 ~     -> key_serial_t ~ [] for [x86_64: 248, aarch64: 217, riscv64: 217, loongarch64: 217, powerpc64: 269, s390x: 278)],
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]   --> src/syscalls.rs:91:3
[INFO] [stdout]    |
[INFO] [stdout] 91 |   alarm(seconds: c_uint) / { seconds: c_uint } -> c_uint ~ [] for [x86_64: 37, powerpc64: 27, s390x: 27],
[INFO] [stdout]    |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 91 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(alarm(seconds: c_uint) / { seconds: c_uint } -> c_uint ~ [] for [x86_64: 37, powerpc64: 27, s390x: 27)],
[INFO] [stdout]    |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]   --> src/syscalls.rs:93:3
[INFO] [stdout]    |
[INFO] [stdout] 93 |   arch_prctl(code: c_int, addr: c_ulong) / {} -> c_int ~ [] for [x86_64: 158], // TODO: addr can be a ptr
[INFO] [stdout]    |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]    |
[INFO] [stdout] 93 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(arch_prctl(code: c_int, addr: c_ulong) / {} -> c_int ~ [] for [x86_64: 158)], // TODO: addr can be a ptr
[INFO] [stdout]    |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                          +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:124:3
[INFO] [stdout]     |
[INFO] [stdout] 124 | /   clock_nanosleep(clockid: clockid_t, flags: c_int, request: *const timespec, remain: *mut timespec) /
[INFO] [stdout] 125 | |   { clockid: clockid_t, flags: c_int, request: timespec } -> c_int + { remain: Option<timespec> }
[INFO] [stdout] 126 | |     ~ [] for [x86_64: 230, aarch64: 115, riscv64: 115, loongarch64: 115, powerpc64: 248, s390x: 262],
[INFO] [stdout]     | |___________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 124 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(clock_nanosleep(clockid: clockid_t, flags: c_int, request: *const timespec, remain: *mut timespec) /
[INFO] [stdout] 125 |   { clockid: clockid_t, flags: c_int, request: timespec } -> c_int + { remain: Option<timespec> }
[INFO] [stdout] 126 ~     ~ [] for [x86_64: 230, aarch64: 115, riscv64: 115, loongarch64: 115, powerpc64: 248, s390x: 262)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:143:3
[INFO] [stdout]     |
[INFO] [stdout] 143 | /   close_range(first: c_uint, last: c_uint, flags: c_uint) / { first: c_uint, last: c_uint, flags: c_uint }
[INFO] [stdout] 144 | |     -> c_int ~ [] for [x86_64: 436, aarch64: 436, riscv64: 436, loongarch64: 436, powerpc64: 436, s390x: 436],
[INFO] [stdout]     | |____________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 143 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(close_range(first: c_uint, last: c_uint, flags: c_uint) / { first: c_uint, last: c_uint, flags: c_uint }
[INFO] [stdout] 144 ~     -> c_int ~ [] for [x86_64: 436, aarch64: 436, riscv64: 436, loongarch64: 436, powerpc64: 436, s390x: 436)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:150:3
[INFO] [stdout]     |
[INFO] [stdout] 150 |   creat(pathname: *const c_char, mode: mode_t) / { pathname: PathBuf, mode: mode_t } -> RawFd ~ [Desc, File] for [x86_64: 85, powerpc64: 8, s390x: 8],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 150 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(creat(pathname: *const c_char, mode: mode_t) / { pathname: PathBuf, mode: mode_t } -> RawFd ~ [Desc, File] for [x86_64: 85, powerpc64: 8, s390x: 8)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                                  +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:151:3
[INFO] [stdout]     |
[INFO] [stdout] 151 |   delete_module(name: *const c_char, flags: c_uint) / { name: CString, flags: c_uint } -> c_int ~ [] for [x86_64: 176, aarch64: 106, riscv64: 106, loongarch64: 106, powerpc64: 129, s390x: 129],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 151 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(delete_module(name: *const c_char, flags: c_uint) / { name: CString, flags: c_uint } -> c_int ~ [] for [x86_64: 176, aarch64: 106, riscv64: 106, loongarch64: 106, powerpc64: 129, s390x: 129)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                                                                             +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:179:3
[INFO] [stdout]     |
[INFO] [stdout] 179 | /   execve(filename: *const c_char, argv: *const *const c_char, envp: *const *const c_char) /
[INFO] [stdout] 180 | |     { filename: PathBuf, argv: Option<Vec<CString>>, envp: Option<Vec<CString>> } -> c_int
[INFO] [stdout] 181 | |     ~ [File, Process] for [x86_64: 59, aarch64: 221, riscv64: 221, loongarch64: 221, powerpc64: 11, s390x: 11],
[INFO] [stdout]     | |_____________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 179 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(execve(filename: *const c_char, argv: *const *const c_char, envp: *const *const c_char) /
[INFO] [stdout] 180 |     { filename: PathBuf, argv: Option<Vec<CString>>, envp: Option<Vec<CString>> } -> c_int
[INFO] [stdout] 181 ~     ~ [File, Process] for [x86_64: 59, aarch64: 221, riscv64: 221, loongarch64: 221, powerpc64: 11, s390x: 11)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:182:3
[INFO] [stdout]     |
[INFO] [stdout] 182 | /   execveat(dirfd: RawFd, pathname: *const c_char, argv: *const *const c_char, envp: *const *const c_char, flags: c_int) /
[INFO] [stdout] 183 | |     { dirfd: RawFd, pathname: PathBuf, argv: Option<Vec<CString>>, envp: Option<Vec<CString>>, flags: c_int }
[INFO] [stdout] 184 | |     -> c_int ~ [Desc, File, Process] for [x86_64: 322, aarch64: 281, riscv64: 281, loongarch64: 281, powerpc64: 362, s390x: 354],
[INFO] [stdout]     | |_______________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 182 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(execveat(dirfd: RawFd, pathname: *const c_char, argv: *const *const c_char, envp: *const *const c_char, flags: c_int) /
[INFO] [stdout] 183 |     { dirfd: RawFd, pathname: PathBuf, argv: Option<Vec<CString>>, envp: Option<Vec<CString>>, flags: c_int }
[INFO] [stdout] 184 ~     -> c_int ~ [Desc, File, Process] for [x86_64: 322, aarch64: 281, riscv64: 281, loongarch64: 281, powerpc64: 362, s390x: 354)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:187:3
[INFO] [stdout]     |
[INFO] [stdout] 187 | /   faccessat(dirfd: RawFd, pathname: *const c_char, mode: c_int) /
[INFO] [stdout] 188 | |     { dirfd: RawFd, pathname: PathBuf, mode: c_int } -> c_int ~ [Desc, File] for [x86_64: 269, aarch64: 48, riscv64: 48, loongarch64: 48, powerpc64: 298, s390x: 300],
[INFO] [stdout]     | |____________________________________________________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 187 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(faccessat(dirfd: RawFd, pathname: *const c_char, mode: c_int) /
[INFO] [stdout] 188 ~     { dirfd: RawFd, pathname: PathBuf, mode: c_int } -> c_int ~ [Desc, File] for [x86_64: 269, aarch64: 48, riscv64: 48, loongarch64: 48, powerpc64: 298, s390x: 300)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:189:3
[INFO] [stdout]     |
[INFO] [stdout] 189 | /   faccessat2(dirfd: RawFd, pathname: *const c_char, mode: c_int, flags: c_int) /
[INFO] [stdout] 190 | |     { dirfd: RawFd, pathname: PathBuf, mode: c_int, flags: c_int } -> c_int ~ [Desc, File] for [x86_64: 439, aarch64: 439, riscv64: 439, loongarch64: 439, powerpc64: 439, s390x: 439],
[INFO] [stdout]     | |_____________________________________________________________________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 189 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(faccessat2(dirfd: RawFd, pathname: *const c_char, mode: c_int, flags: c_int) /
[INFO] [stdout] 190 ~     { dirfd: RawFd, pathname: PathBuf, mode: c_int, flags: c_int } -> c_int ~ [Desc, File] for [x86_64: 439, aarch64: 439, riscv64: 439, loongarch64: 439, powerpc64: 439, s390x: 439)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:199:3
[INFO] [stdout]     |
[INFO] [stdout] 199 | /   fanotify_mark(fanotify_fd: RawFd, flags: c_uint, mask: u64, dirfd: RawFd, pathname: *const c_char) /
[INFO] [stdout] 200 | |     { fanotify_fd: RawFd, flags: c_uint, mask: u64, dirfd: RawFd, pathname: Option<PathBuf> } -> c_int ~ [Desc, File] for [x86_64: 301, aarch64: 263, riscv64: 263, loongarch64: 263, powerpc64: 324, s390x: 333],
[INFO] [stdout]     | |________________________________________________________________________________________________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 199 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(fanotify_mark(fanotify_fd: RawFd, flags: c_uint, mask: u64, dirfd: RawFd, pathname: *const c_char) /
[INFO] [stdout] 200 ~     { fanotify_fd: RawFd, flags: c_uint, mask: u64, dirfd: RawFd, pathname: Option<PathBuf> } -> c_int ~ [Desc, File] for [x86_64: 301, aarch64: 263, riscv64: 263, loongarch64: 263, powerpc64: 324, s390x: 333)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:203:3
[INFO] [stdout]     |
[INFO] [stdout] 203 | /   fchmodat(dirfd: RawFd, pathname: *const c_char, mode: mode_t) /
[INFO] [stdout] 204 | |     { dirfd: RawFd, pathname: PathBuf, mode: mode_t } -> c_int ~ [Desc, File] for [x86_64: 268, aarch64: 53, riscv64: 53, loongarch64: 53, powerpc64: 297, s390x: 299],
[INFO] [stdout]     | |_____________________________________________________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 203 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(fchmodat(dirfd: RawFd, pathname: *const c_char, mode: mode_t) /
[INFO] [stdout] 204 ~     { dirfd: RawFd, pathname: PathBuf, mode: mode_t } -> c_int ~ [Desc, File] for [x86_64: 268, aarch64: 53, riscv64: 53, loongarch64: 53, powerpc64: 297, s390x: 299)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:205:3
[INFO] [stdout]     |
[INFO] [stdout] 205 | /   fchmodat2(dirfd: RawFd, pathname: *const c_char, mode: mode_t, flags: c_int) /
[INFO] [stdout] 206 | |     { dirfd: RawFd, pathname: PathBuf, mode: mode_t, flags: c_int } -> c_int ~ [Desc, File] for [x86_64: 452, aarch64: 452, riscv64: 452, loongarch64: 452, powerpc64: 452, s390x: 452],
[INFO] [stdout]     | |______________________________________________________________________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 205 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(fchmodat2(dirfd: RawFd, pathname: *const c_char, mode: mode_t, flags: c_int) /
[INFO] [stdout] 206 ~     { dirfd: RawFd, pathname: PathBuf, mode: mode_t, flags: c_int } -> c_int ~ [Desc, File] for [x86_64: 452, aarch64: 452, riscv64: 452, loongarch64: 452, powerpc64: 452, s390x: 452)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:209:3
[INFO] [stdout]     |
[INFO] [stdout] 209 | /   fchownat(dirfd: RawFd, pathname: *const c_char, owner: uid_t, group: gid_t, flags: c_int) /
[INFO] [stdout] 210 | |     { dirfd: RawFd, pathname: PathBuf, owner: uid_t, group: gid_t, flags: c_int } -> c_int ~ [Desc, File] for [x86_64: 260, aarch64: 54, riscv64: 54, loongarch64: 54, powerpc64: 289, s390x: 291],
[INFO] [stdout]     | |_________________________________________________________________________________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 209 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(fchownat(dirfd: RawFd, pathname: *const c_char, owner: uid_t, group: gid_t, flags: c_int) /
[INFO] [stdout] 210 ~     { dirfd: RawFd, pathname: PathBuf, owner: uid_t, group: gid_t, flags: c_int } -> c_int ~ [Desc, File] for [x86_64: 260, aarch64: 54, riscv64: 54, loongarch64: 54, powerpc64: 289, s390x: 291)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:218:3
[INFO] [stdout]     |
[INFO] [stdout] 218 | /   file_getattr(dfd: RawFd, filename: *const c_char, fattr: *mut file_attr, size: size_t, at_flags: c_uint) /
[INFO] [stdout] 219 | |     { dfd: RawFd, filename: Option<PathBuf>, size: size_t, at_flags: c_uint } -> c_int + { fattr: file_attr }
[INFO] [stdout] 220 | |     ~ [Desc, File] for [x86_64: 468, aarch64: 468, riscv64: 468, loongarch64: 468, powerpc64: 468, s390x: 468],
[INFO] [stdout]     | |_____________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 218 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(file_getattr(dfd: RawFd, filename: *const c_char, fattr: *mut file_attr, size: size_t, at_flags: c_uint) /
[INFO] [stdout] 219 |     { dfd: RawFd, filename: Option<PathBuf>, size: size_t, at_flags: c_uint } -> c_int + { fattr: file_attr }
[INFO] [stdout] 220 ~     ~ [Desc, File] for [x86_64: 468, aarch64: 468, riscv64: 468, loongarch64: 468, powerpc64: 468, s390x: 468)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:221:3
[INFO] [stdout]     |
[INFO] [stdout] 221 | /   file_setattr(dfd: RawFd, filename: *const c_char, fattr: *const file_attr, size: size_t, at_flags: c_uint) /
[INFO] [stdout] 222 | |     { dfd: RawFd, filename: Option<PathBuf>, fattr: file_attr, size: size_t, at_flags: c_uint } -> c_int
[INFO] [stdout] 223 | |     ~ [Desc, File] for [x86_64: 469, aarch64: 469, riscv64: 469, loongarch64: 469, powerpc64: 469, s390x: 469],
[INFO] [stdout]     | |_____________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 221 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(file_setattr(dfd: RawFd, filename: *const c_char, fattr: *const file_attr, size: size_t, at_flags: c_uint) /
[INFO] [stdout] 222 |     { dfd: RawFd, filename: Option<PathBuf>, fattr: file_attr, size: size_t, at_flags: c_uint } -> c_int
[INFO] [stdout] 223 ~     ~ [Desc, File] for [x86_64: 469, aarch64: 469, riscv64: 469, loongarch64: 469, powerpc64: 469, s390x: 469)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:232:3
[INFO] [stdout]     |
[INFO] [stdout] 232 | /   fsconfig(fd: RawFd, cmd: c_uint, key: *const c_char, value: *const c_char, aux: c_int) /
[INFO] [stdout] 233 | |     { fd: RawFd, cmd: c_uint, key: CString, value: CString, aux: c_int } -> c_int ~ [Desc, File] for [x86_64: 431, aarch64: 431, riscv64: 431, loongarch64: 431, powerpc64: 431, s390x: 431],
[INFO] [stdout]     | |___________________________________________________________________________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 232 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(fsconfig(fd: RawFd, cmd: c_uint, key: *const c_char, value: *const c_char, aux: c_int) /
[INFO] [stdout] 233 ~     { fd: RawFd, cmd: c_uint, key: CString, value: CString, aux: c_int } -> c_int ~ [Desc, File] for [x86_64: 431, aarch64: 431, riscv64: 431, loongarch64: 431, powerpc64: 431, s390x: 431)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:240:3
[INFO] [stdout]     |
[INFO] [stdout] 240 | /   fspick(dirfd: RawFd, pathname: *const c_char, flags: c_uint) / { dirfd: RawFd, pathname: CString, flags: c_uint } -> c_int
[INFO] [stdout] 241 | |     ~ [Desc, File] for [x86_64: 433, aarch64: 433, riscv64: 433, loongarch64: 433, powerpc64: 433, s390x: 433],
[INFO] [stdout]     | |_____________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 240 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(fspick(dirfd: RawFd, pathname: *const c_char, flags: c_uint) / { dirfd: RawFd, pathname: CString, flags: c_uint } -> c_int
[INFO] [stdout] 241 ~     ~ [Desc, File] for [x86_64: 433, aarch64: 433, riscv64: 433, loongarch64: 433, powerpc64: 433, s390x: 433)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:242:3
[INFO] [stdout]     |
[INFO] [stdout] 242 |   fstat(fd: RawFd, statbuf: *mut stat) / { fd: RawFd } -> c_int + { statbuf: stat } ~ [Desc, FStat, StatLike] for [x86_64: 5, aarch64: 80, riscv64: 80, loongarch64: 80, powerpc64: 108, s390x: 108],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 242 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(fstat(fd: RawFd, statbuf: *mut stat) / { fd: RawFd } -> c_int + { statbuf: stat } ~ [Desc, FStat, StatLike] for [x86_64: 5, aarch64: 80, riscv64: 80, loongarch64: 80, powerpc64: 108, s390x: 108)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                                                                                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:244:3
[INFO] [stdout]     |
[INFO] [stdout] 244 |   fstatfs(fd: RawFd, buf: *mut statfs) / { fd: RawFd } -> c_int + { buf: statfs } ~ [Desc, FStatFs, StatFsLike] for [x86_64: 138, aarch64: 44, riscv64: 44, loongarch64: 44, powerpc64: 100, s390x: 100],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 244 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(fstatfs(fd: RawFd, buf: *mut statfs) / { fd: RawFd } -> c_int + { buf: statfs } ~ [Desc, FStatFs, StatFsLike] for [x86_64: 138, aarch64: 44, riscv64: 44, loongarch64: 44, powerpc64: 100, s390x: 100)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                                                                                     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:250:3
[INFO] [stdout]     |
[INFO] [stdout] 250 | /   futex(uaddr: *mut u32, futex_op: c_int, val: u32, val2: usize, uaddr2: *mut u32, val3: u32) /
[INFO] [stdout] 251 | |     { uaddr: InspectResult<u32>, futex_op: c_int, val: u32, val2: usize, uaddr2: InspectResult<u32>, val3: u32 }
[INFO] [stdout] 252 | |     -> c_long + { uaddr: InspectResult<u32>, uaddr2: InspectResult<u32> } ~ [] for [x86_64: 202, aarch64: 98, riscv64: 98, loongarch64: 98, powerpc64: 221, s390x: 238],
[INFO] [stdout]     | |______________________________________________________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 250 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(futex(uaddr: *mut u32, futex_op: c_int, val: u32, val2: usize, uaddr2: *mut u32, val3: u32) /
[INFO] [stdout] 251 |     { uaddr: InspectResult<u32>, futex_op: c_int, val: u32, val2: usize, uaddr2: InspectResult<u32>, val3: u32 }
[INFO] [stdout] 252 ~     -> c_long + { uaddr: InspectResult<u32>, uaddr2: InspectResult<u32> } ~ [] for [x86_64: 202, aarch64: 98, riscv64: 98, loongarch64: 98, powerpc64: 221, s390x: 238)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:255:3
[INFO] [stdout]     |
[INFO] [stdout] 255 | /   futex_requeue(waiters: *mut futex_waitv, flags: c_uint, nr_wake: c_int, nr_requeue: c_int) /
[INFO] [stdout] 256 | |     { waiters: [futex_waitv; 2], flags: c_uint, nr_wake: c_int, nr_requeue: c_int }
[INFO] [stdout] 257 | |     -> c_long + { waiters: [futex_waitv; 2] } ~ [] for [x86_64: 456, aarch64: 456, riscv64: 456, loongarch64: 456, powerpc64: 456, s390x: 456],
[INFO] [stdout]     | |_____________________________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 255 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(futex_requeue(waiters: *mut futex_waitv, flags: c_uint, nr_wake: c_int, nr_requeue: c_int) /
[INFO] [stdout] 256 |     { waiters: [futex_waitv; 2], flags: c_uint, nr_wake: c_int, nr_requeue: c_int }
[INFO] [stdout] 257 ~     -> c_long + { waiters: [futex_waitv; 2] } ~ [] for [x86_64: 456, aarch64: 456, riscv64: 456, loongarch64: 456, powerpc64: 456, s390x: 456)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:259:3
[INFO] [stdout]     |
[INFO] [stdout] 259 | /   futex_wait(uaddr: *mut u32, val: c_ulong, mask: c_ulong, flags: c_uint, timespec: *mut timespec, clockid: clockid_t) /
[INFO] [stdout] 260 | |     { uaddr: InspectResult<u32>, val: c_ulong, mask: c_ulong, flags: c_uint, timespec: timespec, clockid: clockid_t }
[INFO] [stdout] 261 | |     -> c_long + { uaddr: InspectResult<u32> } ~ [] for [x86_64: 455, aarch64: 455, riscv64: 455, loongarch64: 455, powerpc64: 455, s390x: 455],
[INFO] [stdout]     | |_____________________________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 259 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(futex_wait(uaddr: *mut u32, val: c_ulong, mask: c_ulong, flags: c_uint, timespec: *mut timespec, clockid: clockid_t) /
[INFO] [stdout] 260 |     { uaddr: InspectResult<u32>, val: c_ulong, mask: c_ulong, flags: c_uint, timespec: timespec, clockid: clockid_t }
[INFO] [stdout] 261 ~     -> c_long + { uaddr: InspectResult<u32> } ~ [] for [x86_64: 455, aarch64: 455, riscv64: 455, loongarch64: 455, powerpc64: 455, s390x: 455)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:262:3
[INFO] [stdout]     |
[INFO] [stdout] 262 | /   futex_waitv(waiters: *mut futex_waitv, nr_futexes: c_uint, flags: c_uint, timeout: *mut timespec, clockid: clockid_t) /
[INFO] [stdout] 263 | |     { waiters: Vec<futex_waitv> @ counted_by(raw_args.nr_futexes), flags: c_uint, timeout: timespec, clockid: clockid_t }
[INFO] [stdout] 264 | |     -> c_long + { waiters: Vec<futex_waitv> @ counted_by(raw_args.nr_futexes) } ~ [] for [x86_64: 449, aarch64: 449, riscv64: 449, loongarch64: 449, powerpc64: 449, s390x: 449],
[INFO] [stdout]     | |_______________________________________________________________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 262 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(futex_waitv(waiters: *mut futex_waitv, nr_futexes: c_uint, flags: c_uint, timeout: *mut timespec, clockid: clockid_t) /
[INFO] [stdout] 263 |     { waiters: Vec<futex_waitv> @ counted_by(raw_args.nr_futexes), flags: c_uint, timeout: timespec, clockid: clockid_t }
[INFO] [stdout] 264 ~     -> c_long + { waiters: Vec<futex_waitv> @ counted_by(raw_args.nr_futexes) } ~ [] for [x86_64: 449, aarch64: 449, riscv64: 449, loongarch64: 449, powerpc64: 449, s390x: 449)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:265:3
[INFO] [stdout]     |
[INFO] [stdout] 265 | /   futex_wake(uaddr: *mut u32, mask: c_ulong, nr: c_int, flags: c_uint) /
[INFO] [stdout] 266 | |     { uaddr: InspectResult<u32>, mask: c_ulong, nr: c_int, flags: c_uint }
[INFO] [stdout] 267 | |     -> c_long + { uaddr: InspectResult<u32> } ~ [] for [x86_64: 454, aarch64: 454, riscv64: 454, loongarch64: 454, powerpc64: 454, s390x: 454],
[INFO] [stdout]     | |_____________________________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 265 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(futex_wake(uaddr: *mut u32, mask: c_ulong, nr: c_int, flags: c_uint) /
[INFO] [stdout] 266 |     { uaddr: InspectResult<u32>, mask: c_ulong, nr: c_int, flags: c_uint }
[INFO] [stdout] 267 ~     -> c_long + { uaddr: InspectResult<u32> } ~ [] for [x86_64: 454, aarch64: 454, riscv64: 454, loongarch64: 454, powerpc64: 454, s390x: 454)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:268:3
[INFO] [stdout]     |
[INFO] [stdout] 268 | /   futimesat(dirfd: RawFd, pathname: *const c_char, times: *const timeval) /
[INFO] [stdout] 269 | |     { dirfd: RawFd, pathname: PathBuf, times: [timeval;2] } -> c_int ~ [Desc, File] for [x86_64: 261, powerpc64: 290, s390x: 292],
[INFO] [stdout]     | |________________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 268 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(futimesat(dirfd: RawFd, pathname: *const c_char, times: *const timeval) /
[INFO] [stdout] 269 ~     { dirfd: RawFd, pathname: PathBuf, times: [timeval;2] } -> c_int ~ [Desc, File] for [x86_64: 261, powerpc64: 290, s390x: 292)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:276:3
[INFO] [stdout]     |
[INFO] [stdout] 276 | /   get_robust_list(pid: pid_t, head_ptr: *mut *mut robust_list_head, len_ptr: *mut size_t) /
[INFO] [stdout] 277 | |     { pid: pid_t, head_ptr: InspectResult<AddressType>, len_ptr: size_t } -> c_long ~ [] for [x86_64: 274, aarch64: 100, riscv64: 100, loongarch64: 100, powerpc64: 299, s390x: 305],
[INFO] [stdout]     | |___________________________________________________________________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 276 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(get_robust_list(pid: pid_t, head_ptr: *mut *mut robust_list_head, len_ptr: *mut size_t) /
[INFO] [stdout] 277 ~     { pid: pid_t, head_ptr: InspectResult<AddressType>, len_ptr: size_t } -> c_long ~ [] for [x86_64: 274, aarch64: 100, riscv64: 100, loongarch64: 100, powerpc64: 299, s390x: 305)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:278:3
[INFO] [stdout]     |
[INFO] [stdout] 278 |   get_thread_area(u_info: *mut user_desc) / { u_info: user_desc } -> c_int + { u_info: user_desc } ~ [] for [x86_64: 211],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 278 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(get_thread_area(u_info: *mut user_desc) / { u_info: user_desc } -> c_int + { u_info: user_desc } ~ [] for [x86_64: 211)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:279:3
[INFO] [stdout]     |
[INFO] [stdout] 279 | /   getcpu(cpu: *mut c_uint, node: *mut c_uint) /
[INFO] [stdout] 280 | |     { cpu: InspectResult<Option<c_uint>>, node: InspectResult<Option<c_uint>> } -> c_int ~ [] for [x86_64: 309, aarch64: 168, riscv64: 168, loongarch64: 168, powerpc64: 302, s390x: 311],
[INFO] [stdout]     | |________________________________________________________________________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 279 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(getcpu(cpu: *mut c_uint, node: *mut c_uint) /
[INFO] [stdout] 280 ~     { cpu: InspectResult<Option<c_uint>>, node: InspectResult<Option<c_uint>> } -> c_int ~ [] for [x86_64: 309, aarch64: 168, riscv64: 168, loongarch64: 168, powerpc64: 302, s390x: 311)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:291:3
[INFO] [stdout]     |
[INFO] [stdout] 291 |   getegid() / {} -> gid_t ~ [Creds, Pure] for [x86_64: 108, aarch64: 177, riscv64: 177, loongarch64: 177, powerpc64: 50, s390x: 202],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 291 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(getegid() / {} -> gid_t ~ [Creds, Pure] for [x86_64: 108, aarch64: 177, riscv64: 177, loongarch64: 177, powerpc64: 50, s390x: 202)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:293:3
[INFO] [stdout]     |
[INFO] [stdout] 293 |   geteuid() / {} -> uid_t ~ [Creds, Pure] for [x86_64: 107, aarch64: 175, riscv64: 175, loongarch64: 175, powerpc64: 49, s390x: 201],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 293 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(geteuid() / {} -> uid_t ~ [Creds, Pure] for [x86_64: 107, aarch64: 175, riscv64: 175, loongarch64: 175, powerpc64: 49, s390x: 201)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:295:3
[INFO] [stdout]     |
[INFO] [stdout] 295 |   getgid() / {} -> gid_t ~ [Creds, Pure] for [x86_64: 104, aarch64: 176, riscv64: 176, loongarch64: 176, powerpc64: 47, s390x: 200],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 295 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(getgid() / {} -> gid_t ~ [Creds, Pure] for [x86_64: 104, aarch64: 176, riscv64: 176, loongarch64: 176, powerpc64: 47, s390x: 200)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:302:3
[INFO] [stdout]     |
[INFO] [stdout] 302 |   getitimer(which: c_int, value: *mut itimerval) / { which: c_int } -> c_int + { value: itimerval } ~ [] for [x86_64: 36, aarch64: 102, riscv64: 102, loongarch64: 102, powerpc64: 105, s390x: 105],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 302 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(getitimer(which: c_int, value: *mut itimerval) / { which: c_int } -> c_int + { value: itimerval } ~ [] for [x86_64: 36, aarch64: 102, riscv64: 102, loongarch64: 102, powerpc64: 105, s390x: 105)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                                                                                +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:307:3
[INFO] [stdout]     |
[INFO] [stdout] 307 |   getpgid(pid: pid_t) / { pid: pid_t } -> pid_t ~ [] for [x86_64: 121, aarch64: 155, riscv64: 155, loongarch64: 155, powerpc64: 132, s390x: 132],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 307 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(getpgid(pid: pid_t) / { pid: pid_t } -> pid_t ~ [] for [x86_64: 121, aarch64: 155, riscv64: 155, loongarch64: 155, powerpc64: 132, s390x: 132)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                             +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:311:3
[INFO] [stdout]     |
[INFO] [stdout] 311 |   getpriority(which: c_int, who: id_t) / { which: c_int, who: id_t } -> c_int ~ [] for [x86_64: 140, aarch64: 141, riscv64: 141, loongarch64: 141, powerpc64: 96, s390x: 96],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 311 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(getpriority(which: c_int, who: id_t) / { which: c_int, who: id_t } -> c_int ~ [] for [x86_64: 140, aarch64: 141, riscv64: 141, loongarch64: 141, powerpc64: 96, s390x: 96)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                                                         +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:312:3
[INFO] [stdout]     |
[INFO] [stdout] 312 | /   getrandom(buf: *mut c_void, buflen: size_t, flags: c_uint) / { buflen: size_t, flags: c_uint } -> ssize_t + { buf: Vec<u8> @ co...
[INFO] [stdout] 313 | |     ~ [] for [x86_64: 318, aarch64: 278, riscv64: 278, loongarch64: 278, powerpc64: 359, s390x: 349],
[INFO] [stdout]     | |___________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 312 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(getrandom(buf: *mut c_void, buflen: size_t, flags: c_uint) / { buflen: size_t, flags: c_uint } -> ssize_t + { buf: Vec<u8> @ counted_by(raw_args.buflen) }
[INFO] [stdout] 313 ~     ~ [] for [x86_64: 318, aarch64: 278, riscv64: 278, loongarch64: 278, powerpc64: 359, s390x: 349)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:322:3
[INFO] [stdout]     |
[INFO] [stdout] 322 |   getrlimit(resource: c_int, rlim: *mut rlimit) / { resource: c_int } -> c_int + { rlim: rlimit } ~ [] for [x86_64: 97, aarch64: 163, riscv64: 163, s390x: 191],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 322 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(getrlimit(resource: c_int, rlim: *mut rlimit) / { resource: c_int } -> c_int + { rlim: rlimit } ~ [] for [x86_64: 97, aarch64: 163, riscv64: 163, s390x: 191)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                                            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:323:3
[INFO] [stdout]     |
[INFO] [stdout] 323 |   getrusage(who: c_int, usage: *mut rusage) / { who: c_int } -> c_int + { usage: rusage } ~ [] for [x86_64: 98, aarch64: 165, riscv64: 165, loongarch64: 165, powerpc64: 77, s390x: 77],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 323 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(getrusage(who: c_int, usage: *mut rusage) / { who: c_int } -> c_int + { usage: rusage } ~ [] for [x86_64: 98, aarch64: 165, riscv64: 165, loongarch64: 165, powerpc64: 77, s390x: 77)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                                                                    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:324:3
[INFO] [stdout]     |
[INFO] [stdout] 324 |   getsid(pid: pid_t) / { pid: pid_t } -> pid_t ~ [] for [x86_64: 124, aarch64: 156, riscv64: 156, loongarch64: 156, powerpc64: 147, s390x: 147],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 324 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(getsid(pid: pid_t) / { pid: pid_t } -> pid_t ~ [] for [x86_64: 124, aarch64: 156, riscv64: 156, loongarch64: 156, powerpc64: 147, s390x: 147)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:334:3
[INFO] [stdout]     |
[INFO] [stdout] 334 |   getuid() / {} -> uid_t ~ [Creds, Pure] for [x86_64: 102, aarch64: 174, riscv64: 174, loongarch64: 174, powerpc64: 24, s390x: 199],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 334 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(getuid() / {} -> uid_t ~ [Creds, Pure] for [x86_64: 102, aarch64: 174, riscv64: 174, loongarch64: 174, powerpc64: 24, s390x: 199)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:339:3
[INFO] [stdout]     |
[INFO] [stdout] 339 | /   getxattrat(dfd: RawFd, pathname: *const c_char, at_flags: c_uint, name: *const c_char, uargs: *mut c_void, r#usize: size_t) /
[INFO] [stdout] 340 | |     { dfd: RawFd, pathname: PathBuf, at_flags: c_uint, name: CString, uargs: Arc<xattr_args> @ sized_by(raw_args.r#usize) } -> ssize_t ~ [File, Desc] for [x86_64: 464, aarch64: 464, riscv64: 464, loongarch64: 464, powerpc64: 464, s390x: 464],
[INFO] [stdout]     | |________________________________________________________________________________________________________________________________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 339 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(getxattrat(dfd: RawFd, pathname: *const c_char, at_flags: c_uint, name: *const c_char, uargs: *mut c_void, r#usize: size_t) /
[INFO] [stdout] 340 ~     { dfd: RawFd, pathname: PathBuf, at_flags: c_uint, name: CString, uargs: Arc<xattr_args> @ sized_by(raw_args.r#usize) } -> ssize_t ~ [File, Desc] for [x86_64: 464, aarch64: 464, riscv64: 464, loongarch64: 464, powerpc64: 464, s390x: 464)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:344:3
[INFO] [stdout]     |
[INFO] [stdout] 344 | /   init_module(module_image: *mut c_void, len: c_ulong, param_values: *const c_char) /
[INFO] [stdout] 345 | |     { module_image: Vec<u8> @ counted_by(raw_args.len), param_values: CString } -> c_int ~ [] for [x86_64: 175, aarch64: 105, riscv64: 105, loongarch64: 105, powerpc64: 128, s390x: 128],
[INFO] [stdout]     | |________________________________________________________________________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 344 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(init_module(module_image: *mut c_void, len: c_ulong, param_values: *const c_char) /
[INFO] [stdout] 345 ~     { module_image: Vec<u8> @ counted_by(raw_args.len), param_values: CString } -> c_int ~ [] for [x86_64: 175, aarch64: 105, riscv64: 105, loongarch64: 105, powerpc64: 128, s390x: 128)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:346:3
[INFO] [stdout]     |
[INFO] [stdout] 346 | /   inotify_add_watch(fd: RawFd, pathname: *const c_char, mask: u32) /
[INFO] [stdout] 347 | |     { fd: RawFd, pathname: PathBuf, mask: u32 } -> c_int ~ [Desc, File] for [x86_64: 254, aarch64: 27, riscv64: 27, loongarch64: 27, powerpc64: 276, s390x: 285],
[INFO] [stdout]     | |_______________________________________________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 346 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(inotify_add_watch(fd: RawFd, pathname: *const c_char, mask: u32) /
[INFO] [stdout] 347 ~     { fd: RawFd, pathname: PathBuf, mask: u32 } -> c_int ~ [Desc, File] for [x86_64: 254, aarch64: 27, riscv64: 27, loongarch64: 27, powerpc64: 276, s390x: 285)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:351:3
[INFO] [stdout]     |
[INFO] [stdout] 351 | /   io_cancel(ctx_id: aio_context_t, iocb: *mut iocb, result: *mut io_event) /
[INFO] [stdout] 352 | |     { ctx_id: aio_context_t, iocb: iocb } -> c_int + { result: io_event } ~ [] for [x86_64: 210, aarch64: 3, riscv64: 3, loongarch64: 3, powerpc64: 231, s390x: 247],
[INFO] [stdout]     | |___________________________________________________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 351 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(io_cancel(ctx_id: aio_context_t, iocb: *mut iocb, result: *mut io_event) /
[INFO] [stdout] 352 ~     { ctx_id: aio_context_t, iocb: iocb } -> c_int + { result: io_event } ~ [] for [x86_64: 210, aarch64: 3, riscv64: 3, loongarch64: 3, powerpc64: 231, s390x: 247)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:354:3
[INFO] [stdout]     |
[INFO] [stdout] 354 |   io_destroy(ctx_id: aio_context_t) / { ctx_id: aio_context_t } -> c_int ~ [] for [x86_64: 207, aarch64: 1, riscv64: 1, loongarch64: 1, powerpc64: 228, s390x: 244],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 354 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(io_destroy(ctx_id: aio_context_t) / { ctx_id: aio_context_t } -> c_int ~ [] for [x86_64: 207, aarch64: 1, riscv64: 1, loongarch64: 1, powerpc64: 228, s390x: 244)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                                                +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:356:3
[INFO] [stdout]     |
[INFO] [stdout] 356 | /   io_getevents(ctx_id: aio_context_t, min_nr: c_long, nr: c_long, events: *mut io_event, timeout: *mut timespec) /
[INFO] [stdout] 357 | |     { ctx_id: aio_context_t, min_nr: c_long, nr: c_long, timeout: Option<timespec> }
[INFO] [stdout] 358 | |     -> c_int + { events: Vec<io_event> @ counted_by(syscall_result) } ~ [] for [x86_64: 208, aarch64: 4, riscv64: 4, loongarch64: 4, powerpc64: 229, s390x: 245],
[INFO] [stdout]     | |_______________________________________________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 356 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(io_getevents(ctx_id: aio_context_t, min_nr: c_long, nr: c_long, events: *mut io_event, timeout: *mut timespec) /
[INFO] [stdout] 357 |     { ctx_id: aio_context_t, min_nr: c_long, nr: c_long, timeout: Option<timespec> }
[INFO] [stdout] 358 ~     -> c_int + { events: Vec<io_event> @ counted_by(syscall_result) } ~ [] for [x86_64: 208, aarch64: 4, riscv64: 4, loongarch64: 4, powerpc64: 229, s390x: 245)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:359:3
[INFO] [stdout]     |
[INFO] [stdout] 359 | /   io_pgetevents(ctx_id: aio_context_t, min_nr: c_long, nr: c_long, events: *mut io_event, timeout: *mut timespec, sig: *const __aio_sigset) /
[INFO] [stdout] 360 | |     { ctx_id: aio_context_t, min_nr: c_long, nr: c_long, timeout: Option<timespec>, sig: __aio_sigset }
[INFO] [stdout] 361 | |     -> c_int + { events: Vec<io_event> @ counted_by(syscall_result) } ~ [] for [x86_64: 333, aarch64: 292, riscv64: 292, loongarch64: 292, powerpc64: 388, s390x: 382],
[INFO] [stdout]     | |_____________________________________________________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 359 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(io_pgetevents(ctx_id: aio_context_t, min_nr: c_long, nr: c_long, events: *mut io_event, timeout: *mut timespec, sig: *const __aio_sigset) /
[INFO] [stdout] 360 |     { ctx_id: aio_context_t, min_nr: c_long, nr: c_long, timeout: Option<timespec>, sig: __aio_sigset }
[INFO] [stdout] 361 ~     -> c_int + { events: Vec<io_event> @ counted_by(syscall_result) } ~ [] for [x86_64: 333, aarch64: 292, riscv64: 292, loongarch64: 292, powerpc64: 388, s390x: 382)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:366:3
[INFO] [stdout]     |
[INFO] [stdout] 366 | /   io_submit(ctx: aio_context_t, nr: c_long, iocbs: *mut *mut iocb) /
[INFO] [stdout] 367 | |     { ctx: aio_context_t, iocbs: Vec<AddressType> @ counted_by(raw_args.nr) } -> c_int ~ [] for [x86_64: 209, aarch64: 2, riscv64: 2, loongarch64: 2, powerpc64: 230, s390x: 246],
[INFO] [stdout]     | |________________________________________________________________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 366 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(io_submit(ctx: aio_context_t, nr: c_long, iocbs: *mut *mut iocb) /
[INFO] [stdout] 367 ~     { ctx: aio_context_t, iocbs: Vec<AddressType> @ counted_by(raw_args.nr) } -> c_int ~ [] for [x86_64: 209, aarch64: 2, riscv64: 2, loongarch64: 2, powerpc64: 230, s390x: 246)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:369:3
[INFO] [stdout]     |
[INFO] [stdout] 369 | /   io_uring_enter(fd: c_uint, to_submit: c_uint, min_complete: c_uint, flags: c_uint, arg: AddressType, argsz: size_t) /
[INFO] [stdout] 370 | |     { fd: c_uint, to_submit: c_uint, min_complete: c_uint, flags: c_uint, arg: Vec<u8> @ counted_by(raw_args.argsz) }
[INFO] [stdout] 371 | |     -> c_int ~ [Desc, File] for [x86_64: 426, aarch64: 426, riscv64: 426, loongarch64: 426, powerpc64: 426, s390x: 426],
[INFO] [stdout]     | |______________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 369 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(io_uring_enter(fd: c_uint, to_submit: c_uint, min_complete: c_uint, flags: c_uint, arg: AddressType, argsz: size_t) /
[INFO] [stdout] 370 |     { fd: c_uint, to_submit: c_uint, min_complete: c_uint, flags: c_uint, arg: Vec<u8> @ counted_by(raw_args.argsz) }
[INFO] [stdout] 371 ~     -> c_int ~ [Desc, File] for [x86_64: 426, aarch64: 426, riscv64: 426, loongarch64: 426, powerpc64: 426, s390x: 426)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:373:3
[INFO] [stdout]     |
[INFO] [stdout] 373 | /   io_uring_register(fd: c_uint, op: c_uint, arg: AddressType, nr_args: c_uint) /
[INFO] [stdout] 374 | |     { fd: c_uint, op: c_uint, arg: AddressType, nr_args: c_uint } -> c_int ~ [Desc, Memory] for [x86_64: 427, aarch64: 427, riscv64: 427, loongarch64: 427, powerpc64: 427, s390x: 427],
[INFO] [stdout]     | |______________________________________________________________________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 373 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(io_uring_register(fd: c_uint, op: c_uint, arg: AddressType, nr_args: c_uint) /
[INFO] [stdout] 374 ~     { fd: c_uint, op: c_uint, arg: AddressType, nr_args: c_uint } -> c_int ~ [Desc, Memory] for [x86_64: 427, aarch64: 427, riscv64: 427, loongarch64: 427, powerpc64: 427, s390x: 427)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:379:3
[INFO] [stdout]     |
[INFO] [stdout] 379 |   ioperm(from: c_ulong, num: c_ulong, turn_on: c_int) / { from: c_ulong, num: c_ulong, turn_on: c_int } -> c_int ~ [] for [x86_64: 173],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 379 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(ioperm(from: c_ulong, num: c_ulong, turn_on: c_int) / { from: c_ulong, num: c_ulong, turn_on: c_int } -> c_int ~ [] for [x86_64: 173)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:380:3
[INFO] [stdout]     |
[INFO] [stdout] 380 |   iopl(level: c_int) / { level: c_int } -> c_int ~ [] for [x86_64: 172],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 380 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(iopl(level: c_int) / { level: c_int } -> c_int ~ [] for [x86_64: 172)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:381:3
[INFO] [stdout]     |
[INFO] [stdout] 381 |   ioprio_get(which: c_int, who: c_int) / { which: c_int, who: c_int } -> c_int ~ [] for [x86_64: 252, aarch64: 31, riscv64: 31, loongarch64: 31, powerpc64: 274, s390x: 283],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 381 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(ioprio_get(which: c_int, who: c_int) / { which: c_int, who: c_int } -> c_int ~ [] for [x86_64: 252, aarch64: 31, riscv64: 31, loongarch64: 31, powerpc64: 274, s390x: 283)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                                                         +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:382:3
[INFO] [stdout]     |
[INFO] [stdout] 382 |   ioprio_set(which: c_int, who: c_int, ioprio: c_int) / { which: c_int, who: c_int, ioprio: c_int } -> c_int ~ [] for [x86_64: 251, aarch64: 30, riscv64: 30, loongarch64: 30, powerpc64: 273, s390x: 282],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 382 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(ioprio_set(which: c_int, who: c_int, ioprio: c_int) / { which: c_int, who: c_int, ioprio: c_int } -> c_int ~ [] for [x86_64: 251, aarch64: 30, riscv64: 30, loongarch64: 30, powerpc64: 273, s390x: 282)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                                                                                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:384:3
[INFO] [stdout]     |
[INFO] [stdout] 384 | /   kcmp(pid1: pid_t, pid2: pid_t, r#type: c_int, idx1: c_ulong, idx2: c_ulong) /
[INFO] [stdout] 385 | |     { pid1: pid_t, pid2: pid_t, r#type: c_int, idx1: c_ulong, idx2: c_ulong } -> c_int ~ [] for [x86_64: 312, aarch64: 272, riscv64: 272, loongarch64: 272, powerpc64: 354, s390x: 343],
[INFO] [stdout]     | |______________________________________________________________________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 384 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(kcmp(pid1: pid_t, pid2: pid_t, r#type: c_int, idx1: c_ulong, idx2: c_ulong) /
[INFO] [stdout] 385 ~     { pid1: pid_t, pid2: pid_t, r#type: c_int, idx1: c_ulong, idx2: c_ulong } -> c_int ~ [] for [x86_64: 312, aarch64: 272, riscv64: 272, loongarch64: 272, powerpc64: 354, s390x: 343)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:390:3
[INFO] [stdout]     |
[INFO] [stdout] 390 | /   kexec_load(entry: c_ulong, nr_segments: c_ulong, segments: *mut kexec_segment, flags: c_ulong) /
[INFO] [stdout] 391 | |     { entry: c_ulong, segments: Vec<kexec_segment> @ counted_by(raw_args.nr_segments), flags: c_ulong } -> c_long
[INFO] [stdout] 392 | |     ~ [] for [x86_64: 246, aarch64: 104, riscv64: 104, loongarch64: 104, powerpc64: 268, s390x: 277],
[INFO] [stdout]     | |___________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 390 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(kexec_load(entry: c_ulong, nr_segments: c_ulong, segments: *mut kexec_segment, flags: c_ulong) /
[INFO] [stdout] 391 |     { entry: c_ulong, segments: Vec<kexec_segment> @ counted_by(raw_args.nr_segments), flags: c_ulong } -> c_long
[INFO] [stdout] 392 ~     ~ [] for [x86_64: 246, aarch64: 104, riscv64: 104, loongarch64: 104, powerpc64: 268, s390x: 277)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:393:3
[INFO] [stdout]     |
[INFO] [stdout] 393 | /   keyctl(option: c_int, arg2: c_ulong, arg3: c_ulong, arg4: c_ulong, arg5: c_ulong) /
[INFO] [stdout] 394 | |     { option: c_int, arg2: c_ulong, arg3: c_ulong, arg4: c_ulong, arg5: c_ulong } -> c_long ~ [] for [x86_64: 250, aarch64: 219, riscv64: 219, loongarch64: 219, powerpc64: 271, s390x: 280],
[INFO] [stdout]     | |___________________________________________________________________________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 393 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(keyctl(option: c_int, arg2: c_ulong, arg3: c_ulong, arg4: c_ulong, arg5: c_ulong) /
[INFO] [stdout] 394 ~     { option: c_int, arg2: c_ulong, arg3: c_ulong, arg4: c_ulong, arg5: c_ulong } -> c_long ~ [] for [x86_64: 250, aarch64: 219, riscv64: 219, loongarch64: 219, powerpc64: 271, s390x: 280)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:395:3
[INFO] [stdout]     |
[INFO] [stdout] 395 |   kill(pid: pid_t, sig: c_int) / { pid: pid_t, sig: c_int } -> c_int ~ [Signal, Process] for [x86_64: 62, aarch64: 129, riscv64: 129, loongarch64: 129, powerpc64: 37, s390x: 37],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 395 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(kill(pid: pid_t, sig: c_int) / { pid: pid_t, sig: c_int } -> c_int ~ [Signal, Process] for [x86_64: 62, aarch64: 129, riscv64: 129, loongarch64: 129, powerpc64: 37, s390x: 37)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                                                              +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:407:3
[INFO] [stdout]     |
[INFO] [stdout] 407 | /   linkat(olddirfd: RawFd, oldpath: *const c_char, newdirfd: RawFd, newpath: *const c_char, flags: c_int) /
[INFO] [stdout] 408 | |     { olddirfd: RawFd, oldpath: PathBuf, newdirfd: RawFd, newpath: PathBuf, flags: c_int } -> c_int
[INFO] [stdout] 409 | |     ~ [Desc, File] for [x86_64: 265, aarch64: 37, riscv64: 37, loongarch64: 37, powerpc64: 294, s390x: 296],
[INFO] [stdout]     | |__________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 407 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(linkat(olddirfd: RawFd, oldpath: *const c_char, newdirfd: RawFd, newpath: *const c_char, flags: c_int) /
[INFO] [stdout] 408 |     { olddirfd: RawFd, oldpath: PathBuf, newdirfd: RawFd, newpath: PathBuf, flags: c_int } -> c_int
[INFO] [stdout] 409 ~     ~ [Desc, File] for [x86_64: 265, aarch64: 37, riscv64: 37, loongarch64: 37, powerpc64: 294, s390x: 296)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:412:3
[INFO] [stdout]     |
[INFO] [stdout] 412 | /   listmount(req: *const __mount_arg, buf: *mut u64, bufsize: size_t, flags: c_uint) /
[INFO] [stdout] 413 | |     { req: __mount_arg, bufsize: size_t, flags: c_uint } -> c_int + { buf: Vec<u64> @ counted_by(raw_args.bufsize) }
[INFO] [stdout] 414 | |      ~ [] for [x86_64: 458, aarch64: 458, riscv64: 458, loongarch64: 458, powerpc64: 458, s390x: 458],
[INFO] [stdout]     | |____________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 412 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(listmount(req: *const __mount_arg, buf: *mut u64, bufsize: size_t, flags: c_uint) /
[INFO] [stdout] 413 |     { req: __mount_arg, bufsize: size_t, flags: c_uint } -> c_int + { buf: Vec<u64> @ counted_by(raw_args.bufsize) }
[INFO] [stdout] 414 ~      ~ [] for [x86_64: 458, aarch64: 458, riscv64: 458, loongarch64: 458, powerpc64: 458, s390x: 458)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:415:3
[INFO] [stdout]     |
[INFO] [stdout] 415 | /   listns(req: *const ns_id_req, ns_ids: *mut u64, nr_ns_ids: size_t, flags: c_uint) /
[INFO] [stdout] 416 | |     { req: ns_id_req, nr_ns_ids: size_t, flags: c_uint } -> ssize_t + { ns_ids: Vec<u64> @ counted_by(syscall_result) }
[INFO] [stdout] 417 | |     ~ [] for [x86_64: 470, aarch64: 470, riscv64: 470, loongarch64: 470, powerpc64: 470, s390x: 470],
[INFO] [stdout]     | |___________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 415 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(listns(req: *const ns_id_req, ns_ids: *mut u64, nr_ns_ids: size_t, flags: c_uint) /
[INFO] [stdout] 416 |     { req: ns_id_req, nr_ns_ids: size_t, flags: c_uint } -> ssize_t + { ns_ids: Vec<u64> @ counted_by(syscall_result) }
[INFO] [stdout] 417 ~     ~ [] for [x86_64: 470, aarch64: 470, riscv64: 470, loongarch64: 470, powerpc64: 470, s390x: 470)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:422:3
[INFO] [stdout]     |
[INFO] [stdout] 422 | /   listxattrat(dfd: RawFd, pathname: *const c_char, at_flags: c_uint, list: *mut c_char, size: size_t) /
[INFO] [stdout] 423 | |     { dfd: RawFd, pathname: PathBuf, at_flags: c_uint, size: size_t } -> ssize_t + { list: Option<Vec<CString>> }
[INFO] [stdout] 424 | |     ~ [File, Desc] for [x86_64: 465, aarch64: 465, riscv64: 465, loongarch64: 465, powerpc64: 465, s390x: 465],
[INFO] [stdout]     | |_____________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 422 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(listxattrat(dfd: RawFd, pathname: *const c_char, at_flags: c_uint, list: *mut c_char, size: size_t) /
[INFO] [stdout] 423 |     { dfd: RawFd, pathname: PathBuf, at_flags: c_uint, size: size_t } -> ssize_t + { list: Option<Vec<CString>> }
[INFO] [stdout] 424 ~     ~ [File, Desc] for [x86_64: 465, aarch64: 465, riscv64: 465, loongarch64: 465, powerpc64: 465, s390x: 465)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:425:3
[INFO] [stdout]     |
[INFO] [stdout] 425 | /   lookup_dcookie(cookie: u64, buffer: *mut c_char, len: size_t) /
[INFO] [stdout] 426 | |     { cookie: u64, len: size_t } -> c_long + { buffer: PathBuf } ~ [] for [x86_64: 212, aarch64: 18, riscv64: 18, loongarch64: 18],
[INFO] [stdout]     | |_________________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 425 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(lookup_dcookie(cookie: u64, buffer: *mut c_char, len: size_t) /
[INFO] [stdout] 426 ~     { cookie: u64, len: size_t } -> c_long + { buffer: PathBuf } ~ [] for [x86_64: 212, aarch64: 18, riscv64: 18, loongarch64: 18)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:433:3
[INFO] [stdout]     |
[INFO] [stdout] 433 | /   lsm_get_self_attr(attr: c_uint, ctx: *mut c_void, size: *mut u32, flags: u32) / { attr: c_uint, size: InspectResult<u32>, flags:...
[INFO] [stdout] 434 | |     -> c_int + { ctx: Vec<u8> } ~ [] for [x86_64: 459, aarch64: 459, riscv64: 459, loongarch64: 459, powerpc64: 459, s390x: 459],
[INFO] [stdout]     | |_______________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 433 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(lsm_get_self_attr(attr: c_uint, ctx: *mut c_void, size: *mut u32, flags: u32) / { attr: c_uint, size: InspectResult<u32>, flags: u32 }
[INFO] [stdout] 434 ~     -> c_int + { ctx: Vec<u8> } ~ [] for [x86_64: 459, aarch64: 459, riscv64: 459, loongarch64: 459, powerpc64: 459, s390x: 459)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:435:3
[INFO] [stdout]     |
[INFO] [stdout] 435 | /   lsm_list_modules(ids: *mut u64, size: *mut u32, flags: u32) / { size: InspectResult<u32>, flags: u32 }
[INFO] [stdout] 436 | |     -> c_int + { size: InspectResult<u32>, ids: Vec<u64> @ counted_by_result(size) } ~ [] for [x86_64: 461, aarch64: 461, riscv64: 461, loongarch64: 461, powerpc64: 461, s390x: 461],
[INFO] [stdout]     | |____________________________________________________________________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 435 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(lsm_list_modules(ids: *mut u64, size: *mut u32, flags: u32) / { size: InspectResult<u32>, flags: u32 }
[INFO] [stdout] 436 ~     -> c_int + { size: InspectResult<u32>, ids: Vec<u64> @ counted_by_result(size) } ~ [] for [x86_64: 461, aarch64: 461, riscv64: 461, loongarch64: 461, powerpc64: 461, s390x: 461)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:437:3
[INFO] [stdout]     |
[INFO] [stdout] 437 | /   lsm_set_self_attr(attr: c_uint, ctx: *const c_void, size: u32, flags: u32) /
[INFO] [stdout] 438 | |     { attr: c_uint, ctx: Vec<u8> @ counted_by(raw_args.size), flags: u32 } -> c_int ~ [] for [x86_64: 460, aarch64: 460, riscv64: 460, loongarch64: 460, powerpc64: 460, s390x: 460],
[INFO] [stdout]     | |___________________________________________________________________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 437 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(lsm_set_self_attr(attr: c_uint, ctx: *const c_void, size: u32, flags: u32) /
[INFO] [stdout] 438 ~     { attr: c_uint, ctx: Vec<u8> @ counted_by(raw_args.size), flags: u32 } -> c_int ~ [] for [x86_64: 460, aarch64: 460, riscv64: 460, loongarch64: 460, powerpc64: 460, s390x: 460)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:439:3
[INFO] [stdout]     |
[INFO] [stdout] 439 |   lstat(pathname: *const c_char, statbuf: *mut stat) / { pathname: PathBuf } -> c_int + { statbuf: stat } ~ [File, LStat, StatLike] for [x86_64: 6, powerpc64: 107, s390x: 107],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 439 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(lstat(pathname: *const c_char, statbuf: *mut stat) / { pathname: PathBuf } -> c_int + { statbuf: stat } ~ [File, LStat, StatLike] for [x86_64: 6, powerpc64: 107, s390x: 107)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                                                            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:465:3
[INFO] [stdout]     |
[INFO] [stdout] 465 | /   mkdirat(dirfd: RawFd, pathname: *const c_char, mode: mode_t) / { dirfd: RawFd, pathname: PathBuf, mode: mode_t } -> c_int
[INFO] [stdout] 466 | |     ~ [Desc, File] for [x86_64: 258, aarch64: 34, riscv64: 34, loongarch64: 34, powerpc64: 287, s390x: 289],
[INFO] [stdout]     | |__________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 465 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(mkdirat(dirfd: RawFd, pathname: *const c_char, mode: mode_t) / { dirfd: RawFd, pathname: PathBuf, mode: mode_t } -> c_int
[INFO] [stdout] 466 ~     ~ [Desc, File] for [x86_64: 258, aarch64: 34, riscv64: 34, loongarch64: 34, powerpc64: 287, s390x: 289)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:468:3
[INFO] [stdout]     |
[INFO] [stdout] 468 | /   mknodat(dirfd: RawFd, pathname: *const c_char, mode: mode_t, dev: dev_t) /
[INFO] [stdout] 469 | |     { dirfd: RawFd, pathname: PathBuf, mode: mode_t, dev: dev_t } -> c_int ~ [Desc, File] for [x86_64: 259, aarch64: 33, riscv64: 33, loongarch64: 33, powerpc64: 288, s390x: 290],
[INFO] [stdout]     | |_________________________________________________________________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 468 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(mknodat(dirfd: RawFd, pathname: *const c_char, mode: mode_t, dev: dev_t) /
[INFO] [stdout] 469 ~     { dirfd: RawFd, pathname: PathBuf, mode: mode_t, dev: dev_t } -> c_int ~ [Desc, File] for [x86_64: 259, aarch64: 33, riscv64: 33, loongarch64: 33, powerpc64: 288, s390x: 290)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:479:3
[INFO] [stdout]     |
[INFO] [stdout] 479 | /   modify_ldt(func: c_int, ptr: *mut c_void, bytecount: c_ulong) / { func: c_int, ptr: AddressType, bytecount: c_ulong } -> c_int
[INFO] [stdout] 480 | |     ~ [] for [x86_64: 154],
[INFO] [stdout]     | |_________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 479 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(modify_ldt(func: c_int, ptr: *mut c_void, bytecount: c_ulong) / { func: c_int, ptr: AddressType, bytecount: c_ulong } -> c_int
[INFO] [stdout] 480 ~     ~ [] for [x86_64: 154)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:484:3
[INFO] [stdout]     |
[INFO] [stdout] 484 | /   mount_setattr(dirfd: RawFd, pathname: *const c_char, flags: c_uint, uattr: *mut c_void, r#usize: size_t) /
[INFO] [stdout] 485 | |     { dirfd: RawFd, pathname: PathBuf, flags: c_uint, uattr: Arc<mount_attr> @ sized_by(raw_args.r#usize) } -> c_int
[INFO] [stdout] 486 | |     ~ [Desc, File] for [x86_64: 442, aarch64: 442, riscv64: 442, loongarch64: 442, powerpc64: 442, s390x: 442],
[INFO] [stdout]     | |_____________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 484 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(mount_setattr(dirfd: RawFd, pathname: *const c_char, flags: c_uint, uattr: *mut c_void, r#usize: size_t) /
[INFO] [stdout] 485 |     { dirfd: RawFd, pathname: PathBuf, flags: c_uint, uattr: Arc<mount_attr> @ sized_by(raw_args.r#usize) } -> c_int
[INFO] [stdout] 486 ~     ~ [Desc, File] for [x86_64: 442, aarch64: 442, riscv64: 442, loongarch64: 442, powerpc64: 442, s390x: 442)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:487:3
[INFO] [stdout]     |
[INFO] [stdout] 487 | /   move_mount(from_dfd: RawFd, from_path: *const c_char, to_dfd: RawFd, to_path: *const c_char, ms_flags: c_uint) /
[INFO] [stdout] 488 | |     { from_dfd: RawFd, from_path: PathBuf, to_dfd: RawFd, to_path: PathBuf, ms_flags: c_uint } -> c_int
[INFO] [stdout] 489 | |     ~ [Desc, File] for [x86_64: 429, aarch64: 429, riscv64: 429, loongarch64: 429, powerpc64: 429, s390x: 429],
[INFO] [stdout]     | |_____________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 487 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(move_mount(from_dfd: RawFd, from_path: *const c_char, to_dfd: RawFd, to_path: *const c_char, ms_flags: c_uint) /
[INFO] [stdout] 488 |     { from_dfd: RawFd, from_path: PathBuf, to_dfd: RawFd, to_path: PathBuf, ms_flags: c_uint } -> c_int
[INFO] [stdout] 489 ~     ~ [Desc, File] for [x86_64: 429, aarch64: 429, riscv64: 429, loongarch64: 429, powerpc64: 429, s390x: 429)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:515:3
[INFO] [stdout]     |
[INFO] [stdout] 515 |   mq_unlink(name: *const c_char) / { name: CString } -> c_int ~ [] for [x86_64: 241, aarch64: 181, riscv64: 181, loongarch64: 181, powerpc64: 263, s390x: 272],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 515 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(mq_unlink(name: *const c_char) / { name: CString } -> c_int ~ [] for [x86_64: 241, aarch64: 181, riscv64: 181, loongarch64: 181, powerpc64: 263, s390x: 272)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                                           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:522:3
[INFO] [stdout]     |
[INFO] [stdout] 522 | /   msgctl(msqid: c_int, cmd: c_int, buf: *mut msqid_ds) / { msqid: c_int, cmd: c_int } -> c_int + { buf: msqid_ds }
[INFO] [stdout] 523 | |     ~ [] for [x86_64: 71, aarch64: 187, riscv64: 187, loongarch64: 187, powerpc64: 402, s390x: 402],
[INFO] [stdout]     | |__________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 522 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(msgctl(msqid: c_int, cmd: c_int, buf: *mut msqid_ds) / { msqid: c_int, cmd: c_int } -> c_int + { buf: msqid_ds }
[INFO] [stdout] 523 ~     ~ [] for [x86_64: 71, aarch64: 187, riscv64: 187, loongarch64: 187, powerpc64: 402, s390x: 402)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:524:3
[INFO] [stdout]     |
[INFO] [stdout] 524 |   msgget(key: key_t, msgflg: c_int) / { key: key_t, msgflg: c_int } -> c_int ~ [] for [x86_64: 68, aarch64: 186, riscv64: 186, loongarch64: 186, powerpc64: 399, s390x: 399],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 524 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(msgget(key: key_t, msgflg: c_int) / { key: key_t, msgflg: c_int } -> c_int ~ [] for [x86_64: 68, aarch64: 186, riscv64: 186, loongarch64: 186, powerpc64: 399, s390x: 399)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                                                         +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:525:3
[INFO] [stdout]     |
[INFO] [stdout] 525 | /   msgrcv(msqid: c_int, msgp: *mut c_void, msgsz: size_t, msgtyp: c_long, msgflg: c_int) /
[INFO] [stdout] 526 | |     { msqid: c_int, msgsz: size_t, msgtyp: c_long, msgflg: c_int } -> ssize_t + { msgp: Arc<msgbuf> @ sized_by(size_of::<c_long>(...
[INFO] [stdout] 527 | |     ~ [] for [x86_64: 70, aarch64: 188, riscv64: 188, loongarch64: 188, powerpc64: 401, s390x: 401],
[INFO] [stdout]     | |__________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 525 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(msgrcv(msqid: c_int, msgp: *mut c_void, msgsz: size_t, msgtyp: c_long, msgflg: c_int) /
[INFO] [stdout] 526 |     { msqid: c_int, msgsz: size_t, msgtyp: c_long, msgflg: c_int } -> ssize_t + { msgp: Arc<msgbuf> @ sized_by(size_of::<c_long>() + syscall_result as usize) }
[INFO] [stdout] 527 ~     ~ [] for [x86_64: 70, aarch64: 188, riscv64: 188, loongarch64: 188, powerpc64: 401, s390x: 401)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:528:3
[INFO] [stdout]     |
[INFO] [stdout] 528 | /   msgsnd(msqid: c_int, msgp: *const c_void, msgsz: size_t, msgflg: c_int) /
[INFO] [stdout] 529 | |     { msqid: c_int, msgp: Arc<msgbuf> @ sized_by(size_of::<c_long>() + raw_args.msgsz as usize), msgflg: c_int } -> c_int ~ [] for [x86_64: 69, aarch64: 189, riscv64: 189, loongarch64: 189, powerpc64: 400, s390x: 400],
[INFO] [stdout]     | |________________________________________________________________________________________________________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 528 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(msgsnd(msqid: c_int, msgp: *const c_void, msgsz: size_t, msgflg: c_int) /
[INFO] [stdout] 529 ~     { msqid: c_int, msgp: Arc<msgbuf> @ sized_by(size_of::<c_long>() + raw_args.msgsz as usize), msgflg: c_int } -> c_int ~ [] for [x86_64: 69, aarch64: 189, riscv64: 189, loongarch64: 189, powerpc64: 400, s390x: 400)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:536:3
[INFO] [stdout]     |
[INFO] [stdout] 536 | /   name_to_handle_at(dirfd: RawFd, pathname: *const c_char, handle: *mut c_void, mount_id: *mut c_int, flags: c_int) /
[INFO] [stdout] 537 | |     { dirfd: RawFd, pathname: PathBuf, flags: c_int } -> c_int +
[INFO] [stdout] 538 | |     { handle: Arc<file_handle> @ sized_by_result(<InspectResult<c_uint> as InspectFromPid>::inspect_from(inspectee_pid, raw_args....
[INFO] [stdout] 539 | |       mount_id: InspectResult<c_int> }
[INFO] [stdout] 540 | |     ~ [Desc, File] for [x86_64: 303, aarch64: 264, riscv64: 264, loongarch64: 264, powerpc64: 345, s390x: 335],
[INFO] [stdout]     | |_____________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 536 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(name_to_handle_at(dirfd: RawFd, pathname: *const c_char, handle: *mut c_void, mount_id: *mut c_int, flags: c_int) /
[INFO] [stdout] 537 |     { dirfd: RawFd, pathname: PathBuf, flags: c_int } -> c_int +
[INFO] [stdout] 538 |     { handle: Arc<file_handle> @ sized_by_result(<InspectResult<c_uint> as InspectFromPid>::inspect_from(inspectee_pid, raw_args.handle as AddressType)),
[INFO] [stdout] 539 |       mount_id: InspectResult<c_int> }
[INFO] [stdout] 540 ~     ~ [Desc, File] for [x86_64: 303, aarch64: 264, riscv64: 264, loongarch64: 264, powerpc64: 345, s390x: 335)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:543:3
[INFO] [stdout]     |
[INFO] [stdout] 543 | /   newfstatat(dirfd: RawFd, pathname: *const c_char, statbuf: *mut stat, flags: c_int) /
[INFO] [stdout] 544 | |     { dirfd: RawFd, pathname: PathBuf, flags: c_int } -> c_int + { statbuf: stat }
[INFO] [stdout] 545 | |     ~ [Desc, File, FStat, StatLike] for [x86_64: 262, aarch64: 79, riscv64: 79, loongarch64: 79, powerpc64: 291, s390x: 293],
[INFO] [stdout]     | |___________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 543 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(newfstatat(dirfd: RawFd, pathname: *const c_char, statbuf: *mut stat, flags: c_int) /
[INFO] [stdout] 544 |     { dirfd: RawFd, pathname: PathBuf, flags: c_int } -> c_int + { statbuf: stat }
[INFO] [stdout] 545 ~     ~ [Desc, File, FStat, StatLike] for [x86_64: 262, aarch64: 79, riscv64: 79, loongarch64: 79, powerpc64: 291, s390x: 293)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:554:3
[INFO] [stdout]     |
[INFO] [stdout] 554 | /   open(pathname: *const c_char, flags: c_int, mode: mode_t) / { pathname: PathBuf, flags: c_int, mode: mode_t } -> RawFd
[INFO] [stdout] 555 | |     ~ [Desc, File] for [x86_64: 2, aarch64: 56, riscv64: 56, powerpc64: 5, s390x: 5],
[INFO] [stdout]     | |___________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 554 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(open(pathname: *const c_char, flags: c_int, mode: mode_t) / { pathname: PathBuf, flags: c_int, mode: mode_t } -> RawFd
[INFO] [stdout] 555 ~     ~ [Desc, File] for [x86_64: 2, aarch64: 56, riscv64: 56, powerpc64: 5, s390x: 5)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:561:3
[INFO] [stdout]     |
[INFO] [stdout] 561 | /   open_tree(dirfd: RawFd, path: *const c_char, flags: c_uint) / { dirfd: RawFd, path: PathBuf, flags: c_uint } -> c_int
[INFO] [stdout] 562 | |     ~ [Desc, File] for [x86_64: 428, aarch64: 428, riscv64: 428, loongarch64: 428, powerpc64: 428, s390x: 428],
[INFO] [stdout]     | |_____________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 561 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(open_tree(dirfd: RawFd, path: *const c_char, flags: c_uint) / { dirfd: RawFd, path: PathBuf, flags: c_uint } -> c_int
[INFO] [stdout] 562 ~     ~ [Desc, File] for [x86_64: 428, aarch64: 428, riscv64: 428, loongarch64: 428, powerpc64: 428, s390x: 428)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:563:3
[INFO] [stdout]     |
[INFO] [stdout] 563 | /   open_tree_attr(dfd: RawFd, filename: *const c_char, flags: c_uint, uattr: *mut c_void, r#usize: size_t) /
[INFO] [stdout] 564 | |     { dfd: RawFd, filename: PathBuf, flags: c_uint, uattr: Arc<mount_attr> @ sized_by(raw_args.r#usize) } -> c_int
[INFO] [stdout] 565 | |     ~ [Desc, File] for [x86_64: 467, aarch64: 467, riscv64: 467, loongarch64: 467, powerpc64: 467, s390x: 467],
[INFO] [stdout]     | |_____________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 563 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(open_tree_attr(dfd: RawFd, filename: *const c_char, flags: c_uint, uattr: *mut c_void, r#usize: size_t) /
[INFO] [stdout] 564 |     { dfd: RawFd, filename: PathBuf, flags: c_uint, uattr: Arc<mount_attr> @ sized_by(raw_args.r#usize) } -> c_int
[INFO] [stdout] 565 ~     ~ [Desc, File] for [x86_64: 467, aarch64: 467, riscv64: 467, loongarch64: 467, powerpc64: 467, s390x: 467)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:566:3
[INFO] [stdout]     |
[INFO] [stdout] 566 | /   openat(dirfd: RawFd, pathname: *const c_char, flags: c_int, mode: mode_t) /
[INFO] [stdout] 567 | |     { dirfd: RawFd, pathname: PathBuf, flags: c_int, mode: mode_t } -> RawFd ~ [Desc, File] for [x86_64: 257, aarch64: 56, riscv64: 56, loongarch64: 56, powerpc64: 286, s390x: 288],
[INFO] [stdout]     | |___________________________________________________________________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 566 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(openat(dirfd: RawFd, pathname: *const c_char, flags: c_int, mode: mode_t) /
[INFO] [stdout] 567 ~     { dirfd: RawFd, pathname: PathBuf, flags: c_int, mode: mode_t } -> RawFd ~ [Desc, File] for [x86_64: 257, aarch64: 56, riscv64: 56, loongarch64: 56, powerpc64: 286, s390x: 288)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:568:3
[INFO] [stdout]     |
[INFO] [stdout] 568 | /   openat2(dirfd: RawFd, pathname: *const c_char, how: *mut open_how, size: size_t) /
[INFO] [stdout] 569 | |     { dirfd: RawFd, pathname: PathBuf, how: open_how, size: size_t } -> c_int ~ [Desc, File] for [x86_64: 437, aarch64: 437, riscv64: 437, loongarch64: 437, powerpc64: 437, s390x: 437],
[INFO] [stdout]     | |_______________________________________________________________________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 568 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(openat2(dirfd: RawFd, pathname: *const c_char, how: *mut open_how, size: size_t) /
[INFO] [stdout] 569 ~     { dirfd: RawFd, pathname: PathBuf, how: open_how, size: size_t } -> c_int ~ [Desc, File] for [x86_64: 437, aarch64: 437, riscv64: 437, loongarch64: 437, powerpc64: 437, s390x: 437)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:581:3
[INFO] [stdout]     |
[INFO] [stdout] 581 |   personality(persona: c_ulong) / { persona: c_ulong } -> c_int ~ [] for [x86_64: 135, aarch64: 92, riscv64: 92, loongarch64: 92, powerpc64: 136, s390x: 136],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 581 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(personality(persona: c_ulong) / { persona: c_ulong } -> c_int ~ [] for [x86_64: 135, aarch64: 92, riscv64: 92, loongarch64: 92, powerpc64: 136, s390x: 136)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                                          +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:585:3
[INFO] [stdout]     |
[INFO] [stdout] 585 | /   pidfd_send_signal(pidfd: RawFd, sig: c_int, info: *mut siginfo_t, flags: c_uint) /
[INFO] [stdout] 586 | |     { pidfd: RawFd, sig: c_int, info: Option<siginfo_t>, flags: c_uint } -> c_int
[INFO] [stdout] 587 | |     ~ [Desc, Signal, Process] for [x86_64: 424, aarch64: 424, riscv64: 424, loongarch64: 424, powerpc64: 424, s390x: 424],
[INFO] [stdout]     | |________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 585 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(pidfd_send_signal(pidfd: RawFd, sig: c_int, info: *mut siginfo_t, flags: c_uint) /
[INFO] [stdout] 586 |     { pidfd: RawFd, sig: c_int, info: Option<siginfo_t>, flags: c_uint } -> c_int
[INFO] [stdout] 587 ~     ~ [Desc, Signal, Process] for [x86_64: 424, aarch64: 424, riscv64: 424, loongarch64: 424, powerpc64: 424, s390x: 424)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:592:3
[INFO] [stdout]     |
[INFO] [stdout] 592 |   pkey_alloc(flags: c_uint, access_rights: c_uint) / { flags: c_uint, access_rights: c_uint } -> c_int ~ [] for [x86_64: 330, aarch64: 289, riscv64: 289, loongarch64: 289, powerpc64: 384, s390x: 385],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 592 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(pkey_alloc(flags: c_uint, access_rights: c_uint) / { flags: c_uint, access_rights: c_uint } -> c_int ~ [] for [x86_64: 330, aarch64: 289, riscv64: 289, loongarch64: 289, powerpc64: 384, s390x: 385)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                                                                                    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:593:3
[INFO] [stdout]     |
[INFO] [stdout] 593 |   pkey_free(pkey: c_int) / { pkey: c_int } -> c_int ~ [] for [x86_64: 331, aarch64: 290, riscv64: 290, loongarch64: 290, powerpc64: 385, s390x: 386],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 593 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(pkey_free(pkey: c_int) / { pkey: c_int } -> c_int ~ [] for [x86_64: 331, aarch64: 290, riscv64: 290, loongarch64: 290, powerpc64: 385, s390x: 386)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:613:3
[INFO] [stdout]     |
[INFO] [stdout] 613 | /   prlimit64(pid: pid_t, resource: c_int, new_limit: *const rlimit64, old_limit: *mut rlimit64) /
[INFO] [stdout] 614 | |     { pid: pid_t, resource: c_int, new_limit: Option<rlimit64>, old_limit: Option<rlimit64> } -> c_int + { old_limit: Option<rlim...
[INFO] [stdout] 615 | |     ~ [] for [x86_64: 302, aarch64: 261, riscv64: 261, loongarch64: 261, powerpc64: 325, s390x: 334],
[INFO] [stdout]     | |___________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 613 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(prlimit64(pid: pid_t, resource: c_int, new_limit: *const rlimit64, old_limit: *mut rlimit64) /
[INFO] [stdout] 614 |     { pid: pid_t, resource: c_int, new_limit: Option<rlimit64>, old_limit: Option<rlimit64> } -> c_int + { old_limit: Option<rlimit64> }
[INFO] [stdout] 615 ~     ~ [] for [x86_64: 302, aarch64: 261, riscv64: 261, loongarch64: 261, powerpc64: 325, s390x: 334)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:620:3
[INFO] [stdout]     |
[INFO] [stdout] 620 | /   process_vm_readv(pid: pid_t, local_iov: *const iovec, liovcnt: c_ulong, remote_iov: *const iovec, riovcnt: c_ulong, flags: c_ul...
[INFO] [stdout] 621 | |     { pid: pid_t, local_iov: Vec<iovec> @ counted_by(raw_args.liovcnt), remote_iov: Vec<iovec> @ counted_by(raw_args.riovcnt), fl...
[INFO] [stdout] 622 | |     -> ssize_t ~ [] for [x86_64: 310, aarch64: 270, riscv64: 270, loongarch64: 270, powerpc64: 351, s390x: 340],
[INFO] [stdout]     | |______________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 620 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(process_vm_readv(pid: pid_t, local_iov: *const iovec, liovcnt: c_ulong, remote_iov: *const iovec, riovcnt: c_ulong, flags: c_ulong) /
[INFO] [stdout] 621 |     { pid: pid_t, local_iov: Vec<iovec> @ counted_by(raw_args.liovcnt), remote_iov: Vec<iovec> @ counted_by(raw_args.riovcnt), flags: c_ulong }
[INFO] [stdout] 622 ~     -> ssize_t ~ [] for [x86_64: 310, aarch64: 270, riscv64: 270, loongarch64: 270, powerpc64: 351, s390x: 340)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:623:3
[INFO] [stdout]     |
[INFO] [stdout] 623 | /   process_vm_writev(pid: pid_t, local_iov: *const iovec, liovcnt: c_ulong, remote_iov: *const iovec, riovcnt: c_ulong, flags: c_u...
[INFO] [stdout] 624 | |     { pid: pid_t, local_iov: Vec<iovec> @ counted_by(raw_args.liovcnt), remote_iov: Vec<iovec> @ counted_by(raw_args.riovcnt), fl...
[INFO] [stdout] 625 | |     -> ssize_t ~ [] for [x86_64: 311, aarch64: 271, riscv64: 271, loongarch64: 271, powerpc64: 352, s390x: 341],
[INFO] [stdout]     | |______________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 623 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(process_vm_writev(pid: pid_t, local_iov: *const iovec, liovcnt: c_ulong, remote_iov: *const iovec, riovcnt: c_ulong, flags: c_ulong) /
[INFO] [stdout] 624 |     { pid: pid_t, local_iov: Vec<iovec> @ counted_by(raw_args.liovcnt), remote_iov: Vec<iovec> @ counted_by(raw_args.riovcnt), flags: c_ulong }
[INFO] [stdout] 625 ~     -> ssize_t ~ [] for [x86_64: 311, aarch64: 271, riscv64: 271, loongarch64: 271, powerpc64: 352, s390x: 341)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:632:3
[INFO] [stdout]     |
[INFO] [stdout] 632 | /   ptrace(request: c_int, pid: pid_t, addr: *mut c_void, data: *mut c_void) / { } -> c_long
[INFO] [stdout] 633 | |     ~ [] for [x86_64: 101, aarch64: 117, riscv64: 117, loongarch64: 117, powerpc64: 26, s390x: 26],
[INFO] [stdout]     | |_________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 632 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(ptrace(request: c_int, pid: pid_t, addr: *mut c_void, data: *mut c_void) / { } -> c_long
[INFO] [stdout] 633 ~     ~ [] for [x86_64: 101, aarch64: 117, riscv64: 117, loongarch64: 117, powerpc64: 26, s390x: 26)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:651:3
[INFO] [stdout]     |
[INFO] [stdout] 651 | /   readlinkat(dirfd: RawFd, pathname: *const c_char, buf: *mut c_char, bufsiz: size_t) /
[INFO] [stdout] 652 | |     { dirfd: RawFd, pathname: PathBuf, bufsiz: size_t } -> ssize_t + { buf: Vec<u8> @ counted_by(syscall_result) }
[INFO] [stdout] 653 | |     ~ [Desc, File] for [x86_64: 267, aarch64: 78, riscv64: 78, loongarch64: 78, powerpc64: 296, s390x: 298],
[INFO] [stdout]     | |__________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 651 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(readlinkat(dirfd: RawFd, pathname: *const c_char, buf: *mut c_char, bufsiz: size_t) /
[INFO] [stdout] 652 |     { dirfd: RawFd, pathname: PathBuf, bufsiz: size_t } -> ssize_t + { buf: Vec<u8> @ counted_by(syscall_result) }
[INFO] [stdout] 653 ~     ~ [Desc, File] for [x86_64: 267, aarch64: 78, riscv64: 78, loongarch64: 78, powerpc64: 296, s390x: 298)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:656:3
[INFO] [stdout]     |
[INFO] [stdout] 656 | /   reboot(magic: c_int, magic2: c_int, cmd: c_int, arg: *mut c_void) / { magic: c_int, magic2: c_int, cmd: c_int } -> c_int
[INFO] [stdout] 657 | |     ~ [] for [x86_64: 169, aarch64: 142, riscv64: 142, loongarch64: 142, powerpc64: 88, s390x: 88],
[INFO] [stdout]     | |_________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 656 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(reboot(magic: c_int, magic2: c_int, cmd: c_int, arg: *mut c_void) / { magic: c_int, magic2: c_int, cmd: c_int } -> c_int
[INFO] [stdout] 657 ~     ~ [] for [x86_64: 169, aarch64: 142, riscv64: 142, loongarch64: 142, powerpc64: 88, s390x: 88)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:673:3
[INFO] [stdout]     |
[INFO] [stdout] 673 | /   removexattrat(dfd: RawFd, pathname: *const c_char, at_flags: c_uint, name: *const c_char) /
[INFO] [stdout] 674 | |     { dfd: RawFd, pathname: PathBuf, at_flags: c_uint, name: CString } -> c_int
[INFO] [stdout] 675 | |     ~ [File, Desc] for [x86_64: 466, aarch64: 466, riscv64: 466, loongarch64: 466, powerpc64: 466, s390x: 466],
[INFO] [stdout]     | |_____________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 673 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(removexattrat(dfd: RawFd, pathname: *const c_char, at_flags: c_uint, name: *const c_char) /
[INFO] [stdout] 674 |     { dfd: RawFd, pathname: PathBuf, at_flags: c_uint, name: CString } -> c_int
[INFO] [stdout] 675 ~     ~ [File, Desc] for [x86_64: 466, aarch64: 466, riscv64: 466, loongarch64: 466, powerpc64: 466, s390x: 466)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:678:3
[INFO] [stdout]     |
[INFO] [stdout] 678 | /   renameat(olddirfd: RawFd, oldpath: *const c_char, newdirfd: RawFd, newpath: *const c_char) /
[INFO] [stdout] 679 | |     { olddirfd: RawFd, oldpath: PathBuf, newdirfd: RawFd, newpath: PathBuf } -> c_int
[INFO] [stdout] 680 | |     ~ [Desc, File] for [x86_64: 264, aarch64: 38, powerpc64: 293, s390x: 295],
[INFO] [stdout]     | |____________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 678 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(renameat(olddirfd: RawFd, oldpath: *const c_char, newdirfd: RawFd, newpath: *const c_char) /
[INFO] [stdout] 679 |     { olddirfd: RawFd, oldpath: PathBuf, newdirfd: RawFd, newpath: PathBuf } -> c_int
[INFO] [stdout] 680 ~     ~ [Desc, File] for [x86_64: 264, aarch64: 38, powerpc64: 293, s390x: 295)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:681:3
[INFO] [stdout]     |
[INFO] [stdout] 681 | /   renameat2(olddirfd: RawFd, oldpath: *const c_char, newdirfd: RawFd, newpath: *const c_char, flags: c_uint) /
[INFO] [stdout] 682 | |     { olddirfd: RawFd, oldpath: PathBuf, newdirfd: RawFd, newpath: PathBuf, flags: c_uint } -> c_int
[INFO] [stdout] 683 | |     ~ [Desc, File] for [x86_64: 316, aarch64: 276, riscv64: 276, loongarch64: 276, powerpc64: 357, s390x: 347],
[INFO] [stdout]     | |_____________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 681 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(renameat2(olddirfd: RawFd, oldpath: *const c_char, newdirfd: RawFd, newpath: *const c_char, flags: c_uint) /
[INFO] [stdout] 682 |     { olddirfd: RawFd, oldpath: PathBuf, newdirfd: RawFd, newpath: PathBuf, flags: c_uint } -> c_int
[INFO] [stdout] 683 ~     ~ [Desc, File] for [x86_64: 316, aarch64: 276, riscv64: 276, loongarch64: 276, powerpc64: 357, s390x: 347)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:684:3
[INFO] [stdout]     |
[INFO] [stdout] 684 | /   request_key(r#type: *const c_char, description: *const c_char, callout_info: *const c_char, dest_keyring: key_serial_t) /
[INFO] [stdout] 685 | |     { r#type: CString, description: CString, callout_info: Option<CString>, dest_keyring: key_serial_t } -> key_serial_t
[INFO] [stdout] 686 | |     ~ [] for [x86_64: 249, aarch64: 218, riscv64: 218, loongarch64: 218, powerpc64: 270, s390x: 279],
[INFO] [stdout]     | |___________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 684 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(request_key(r#type: *const c_char, description: *const c_char, callout_info: *const c_char, dest_keyring: key_serial_t) /
[INFO] [stdout] 685 |     { r#type: CString, description: CString, callout_info: Option<CString>, dest_keyring: key_serial_t } -> key_serial_t
[INFO] [stdout] 686 ~     ~ [] for [x86_64: 249, aarch64: 218, riscv64: 218, loongarch64: 218, powerpc64: 270, s390x: 279)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:687:3
[INFO] [stdout]     |
[INFO] [stdout] 687 |   restart_syscall() / {} -> c_long ~ [] for [x86_64: 219, aarch64: 128, riscv64: 128, loongarch64: 128, powerpc64: 0, s390x: 7],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 687 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(restart_syscall() / {} -> c_long ~ [] for [x86_64: 219, aarch64: 128, riscv64: 128, loongarch64: 128, powerpc64: 0, s390x: 7)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:698:3
[INFO] [stdout]     |
[INFO] [stdout] 698 | /   rseq(rseq: *mut c_void, rseq_len: u32, flags: c_int, sig: u32) / { rseq: Arc<rseq> @ sized_by(raw_args.rseq_len), flags: c_int,...
[INFO] [stdout] 699 | |     ~ [] for [x86_64: 334, aarch64: 293, riscv64: 293, loongarch64: 293, powerpc64: 387, s390x: 383],
[INFO] [stdout]     | |___________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 698 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(rseq(rseq: *mut c_void, rseq_len: u32, flags: c_int, sig: u32) / { rseq: Arc<rseq> @ sized_by(raw_args.rseq_len), flags: c_int, sig: u32 } -> c_int
[INFO] [stdout] 699 ~     ~ [] for [x86_64: 334, aarch64: 293, riscv64: 293, loongarch64: 293, powerpc64: 387, s390x: 383)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:700:3
[INFO] [stdout]     |
[INFO] [stdout] 700 |   rseq_slice_yield() / {} -> c_int ~ [] for [x86_64: 471, aarch64: 471, riscv64: 471, loongarch64: 471, powerpc64: 471, s390x: 471],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 700 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(rseq_slice_yield() / {} -> c_int ~ [] for [x86_64: 471, aarch64: 471, riscv64: 471, loongarch64: 471, powerpc64: 471, s390x: 471)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:709:3
[INFO] [stdout]     |
[INFO] [stdout] 709 | /   rt_sigqueueinfo(pid: pid_t, sig: c_int, info: *mut siginfo_t) / { pid: pid_t, sig: c_int, info: siginfo_t } -> c_int
[INFO] [stdout] 710 | |     ~ [Signal, Process] for [x86_64: 129, aarch64: 138, riscv64: 138, loongarch64: 138, powerpc64: 177, s390x: 178],
[INFO] [stdout]     | |__________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 709 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(rt_sigqueueinfo(pid: pid_t, sig: c_int, info: *mut siginfo_t) / { pid: pid_t, sig: c_int, info: siginfo_t } -> c_int
[INFO] [stdout] 710 ~     ~ [Signal, Process] for [x86_64: 129, aarch64: 138, riscv64: 138, loongarch64: 138, powerpc64: 177, s390x: 178)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:719:3
[INFO] [stdout]     |
[INFO] [stdout] 719 | /   rt_tgsigqueueinfo(tgid: pid_t, pid: pid_t, sig: c_int, info: *mut siginfo_t) /
[INFO] [stdout] 720 | |     { tgid: pid_t, pid: pid_t, sig: c_int, info: siginfo_t } -> c_int ~ [Signal, Process] for [x86_64: 297, aarch64: 240, riscv64: 240, loongarch64: 240, powerpc64: 322, s390x: 330],
[INFO] [stdout]     | |____________________________________________________________________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 719 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(rt_tgsigqueueinfo(tgid: pid_t, pid: pid_t, sig: c_int, info: *mut siginfo_t) /
[INFO] [stdout] 720 ~     { tgid: pid_t, pid: pid_t, sig: c_int, info: siginfo_t } -> c_int ~ [Signal, Process] for [x86_64: 297, aarch64: 240, riscv64: 240, loongarch64: 240, powerpc64: 322, s390x: 330)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:723:3
[INFO] [stdout]     |
[INFO] [stdout] 723 |   sched_get_priority_max(policy: c_int) / { policy: c_int } -> c_int ~ [] for [x86_64: 146, aarch64: 125, riscv64: 125, loongarch64: 125, powerpc64: 159, s390x: 159],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 723 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(sched_get_priority_max(policy: c_int) / { policy: c_int } -> c_int ~ [] for [x86_64: 146, aarch64: 125, riscv64: 125, loongarch64: 125, powerpc64: 159, s390x: 159)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                                                  +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `ptrace-syscalls` (lib test) due to 159 previous errors; 1 warning emitted
[INFO] [stderr] warning: build failed, waiting for other jobs to finish...
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:724:3
[INFO] [stdout]     |
[INFO] [stdout] 724 |   sched_get_priority_min(policy: c_int) / { policy: c_int } -> c_int ~ [] for [x86_64: 147, aarch64: 126, riscv64: 126, loongarch64: 126, powerpc64: 160, s390x: 160],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 724 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(sched_get_priority_min(policy: c_int) / { policy: c_int } -> c_int ~ [] for [x86_64: 147, aarch64: 126, riscv64: 126, loongarch64: 126, powerpc64: 160, s390x: 160)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                                                  +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:726:3
[INFO] [stdout]     |
[INFO] [stdout] 726 | /   sched_getaffinity(pid: pid_t, cpusetsize: size_t, mask: *mut c_ulong) /
[INFO] [stdout] 727 | |     { pid: pid_t, cpusetsize: size_t } -> c_int + { mask: Vec<u8> @ counted_by(syscall_result) }
[INFO] [stdout] 728 | |     ~ [] for [x86_64: 204, aarch64: 123, riscv64: 123, loongarch64: 123, powerpc64: 223, s390x: 240],
[INFO] [stdout]     | |___________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 726 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(sched_getaffinity(pid: pid_t, cpusetsize: size_t, mask: *mut c_ulong) /
[INFO] [stdout] 727 |     { pid: pid_t, cpusetsize: size_t } -> c_int + { mask: Vec<u8> @ counted_by(syscall_result) }
[INFO] [stdout] 728 ~     ~ [] for [x86_64: 204, aarch64: 123, riscv64: 123, loongarch64: 123, powerpc64: 223, s390x: 240)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:729:3
[INFO] [stdout]     |
[INFO] [stdout] 729 | /   sched_getattr(pid: pid_t, attr: *mut sched_attr, size: c_uint, flags: c_uint) /
[INFO] [stdout] 730 | |     { pid: pid_t, size: c_uint, flags: c_uint } -> c_int + { attr: sched_attr }
[INFO] [stdout] 731 | |     ~ [] for [x86_64: 315, aarch64: 275, riscv64: 275, loongarch64: 275, powerpc64: 356, s390x: 346],
[INFO] [stdout]     | |___________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 729 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(sched_getattr(pid: pid_t, attr: *mut sched_attr, size: c_uint, flags: c_uint) /
[INFO] [stdout] 730 |     { pid: pid_t, size: c_uint, flags: c_uint } -> c_int + { attr: sched_attr }
[INFO] [stdout] 731 ~     ~ [] for [x86_64: 315, aarch64: 275, riscv64: 275, loongarch64: 275, powerpc64: 356, s390x: 346)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:732:3
[INFO] [stdout]     |
[INFO] [stdout] 732 | /   sched_getparam(pid: pid_t, param: *mut sched_param) / { pid: pid_t } -> c_int + { param: sched_param }
[INFO] [stdout] 733 | |     ~ [] for [x86_64: 143, aarch64: 121, riscv64: 121, loongarch64: 121, powerpc64: 155, s390x: 155],
[INFO] [stdout]     | |___________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 732 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(sched_getparam(pid: pid_t, param: *mut sched_param) / { pid: pid_t } -> c_int + { param: sched_param }
[INFO] [stdout] 733 ~     ~ [] for [x86_64: 143, aarch64: 121, riscv64: 121, loongarch64: 121, powerpc64: 155, s390x: 155)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:734:3
[INFO] [stdout]     |
[INFO] [stdout] 734 |   sched_getscheduler(pid: pid_t) / { pid: pid_t } -> c_int ~ [] for [x86_64: 145, aarch64: 120, riscv64: 120, loongarch64: 120, powerpc64: 157, s390x: 157],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 734 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(sched_getscheduler(pid: pid_t) / { pid: pid_t } -> c_int ~ [] for [x86_64: 145, aarch64: 120, riscv64: 120, loongarch64: 120, powerpc64: 157, s390x: 157)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                                        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:735:3
[INFO] [stdout]     |
[INFO] [stdout] 735 | /   sched_rr_get_interval(pid: pid_t, tp: *mut timespec) / { pid: pid_t } -> c_int + { tp: timespec }
[INFO] [stdout] 736 | |     ~ [] for [x86_64: 148, aarch64: 127, riscv64: 127, loongarch64: 127, powerpc64: 161, s390x: 161],
[INFO] [stdout]     | |___________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 735 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(sched_rr_get_interval(pid: pid_t, tp: *mut timespec) / { pid: pid_t } -> c_int + { tp: timespec }
[INFO] [stdout] 736 ~     ~ [] for [x86_64: 148, aarch64: 127, riscv64: 127, loongarch64: 127, powerpc64: 161, s390x: 161)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:739:3
[INFO] [stdout]     |
[INFO] [stdout] 739 | /   sched_setaffinity(pid: pid_t, cpusetsize: size_t, mask: *const c_ulong) /
[INFO] [stdout] 740 | |     { pid: pid_t, cpusetsize: size_t, mask: Vec<u8> @ counted_by(cpusetsize) } -> c_int
[INFO] [stdout] 741 | |     ~ [] for [x86_64: 203, aarch64: 122, riscv64: 122, loongarch64: 122, powerpc64: 222, s390x: 239],
[INFO] [stdout]     | |___________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 739 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(sched_setaffinity(pid: pid_t, cpusetsize: size_t, mask: *const c_ulong) /
[INFO] [stdout] 740 |     { pid: pid_t, cpusetsize: size_t, mask: Vec<u8> @ counted_by(cpusetsize) } -> c_int
[INFO] [stdout] 741 ~     ~ [] for [x86_64: 203, aarch64: 122, riscv64: 122, loongarch64: 122, powerpc64: 222, s390x: 239)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:743:3
[INFO] [stdout]     |
[INFO] [stdout] 743 | /   sched_setattr(pid: pid_t, attr: *mut sched_attr, flags: c_uint) / { pid: pid_t, attr: sched_attr, flags: c_uint } -> c_int
[INFO] [stdout] 744 | |     ~ [] for [x86_64: 314, aarch64: 274, riscv64: 274, loongarch64: 274, powerpc64: 355, s390x: 345],
[INFO] [stdout]     | |___________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 743 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(sched_setattr(pid: pid_t, attr: *mut sched_attr, flags: c_uint) / { pid: pid_t, attr: sched_attr, flags: c_uint } -> c_int
[INFO] [stdout] 744 ~     ~ [] for [x86_64: 314, aarch64: 274, riscv64: 274, loongarch64: 274, powerpc64: 355, s390x: 345)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:745:3
[INFO] [stdout]     |
[INFO] [stdout] 745 | /   sched_setparam(pid: pid_t, param: *const sched_param) / { pid: pid_t, param: sched_param } -> c_int
[INFO] [stdout] 746 | |     ~ [] for [x86_64: 142, aarch64: 118, riscv64: 118, loongarch64: 118, powerpc64: 154, s390x: 154],
[INFO] [stdout]     | |___________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 745 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(sched_setparam(pid: pid_t, param: *const sched_param) / { pid: pid_t, param: sched_param } -> c_int
[INFO] [stdout] 746 ~     ~ [] for [x86_64: 142, aarch64: 118, riscv64: 118, loongarch64: 118, powerpc64: 154, s390x: 154)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:747:3
[INFO] [stdout]     |
[INFO] [stdout] 747 | /   sched_setscheduler(pid: pid_t, policy: c_int, param: *const sched_param) /
[INFO] [stdout] 748 | |     { pid: pid_t, policy: c_int, param: sched_param } -> c_int
[INFO] [stdout] 749 | |     ~ [] for [x86_64: 144, aarch64: 119, riscv64: 119, loongarch64: 119, powerpc64: 156, s390x: 156],
[INFO] [stdout]     | |___________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 747 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(sched_setscheduler(pid: pid_t, policy: c_int, param: *const sched_param) /
[INFO] [stdout] 748 |     { pid: pid_t, policy: c_int, param: sched_param } -> c_int
[INFO] [stdout] 749 ~     ~ [] for [x86_64: 144, aarch64: 119, riscv64: 119, loongarch64: 119, powerpc64: 156, s390x: 156)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:750:3
[INFO] [stdout]     |
[INFO] [stdout] 750 |   sched_yield() / {} -> c_int ~ [] for [x86_64: 24, aarch64: 124, riscv64: 124, loongarch64: 124, powerpc64: 158, s390x: 158],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 750 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(sched_yield() / {} -> c_int ~ [] for [x86_64: 24, aarch64: 124, riscv64: 124, loongarch64: 124, powerpc64: 158, s390x: 158)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                          +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:752:3
[INFO] [stdout]     |
[INFO] [stdout] 752 | /   seccomp(operation: c_int, flags: c_uint, args: *mut c_void) / { operation: c_int, flags: c_uint } -> c_int
[INFO] [stdout] 753 | |     ~ [] for [x86_64: 317, aarch64: 277, riscv64: 277, loongarch64: 277, powerpc64: 358, s390x: 348],
[INFO] [stdout]     | |___________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 752 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(seccomp(operation: c_int, flags: c_uint, args: *mut c_void) / { operation: c_int, flags: c_uint } -> c_int
[INFO] [stdout] 753 ~     ~ [] for [x86_64: 317, aarch64: 277, riscv64: 277, loongarch64: 277, powerpc64: 358, s390x: 348)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:770:3
[INFO] [stdout]     |
[INFO] [stdout] 770 | /   sendfile(out_fd: RawFd, in_fd: RawFd, offset: *mut off_t, count: size_t) /
[INFO] [stdout] 771 | |     { out_fd: RawFd, in_fd: RawFd, offset: off_t, count: size_t } -> ssize_t ~ [Desc, Network] for [x86_64: 40, aarch64: 71, riscv64: 71, loongarch64: 71, powerpc64: 186, s390x: 187],
[INFO] [stdout]     | |_____________________________________________________________________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 770 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(sendfile(out_fd: RawFd, in_fd: RawFd, offset: *mut off_t, count: size_t) /
[INFO] [stdout] 771 ~     { out_fd: RawFd, in_fd: RawFd, offset: off_t, count: size_t } -> ssize_t ~ [Desc, Network] for [x86_64: 40, aarch64: 71, riscv64: 71, loongarch64: 71, powerpc64: 186, s390x: 187)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:789:3
[INFO] [stdout]     |
[INFO] [stdout] 789 | /   set_robust_list(head: *mut robust_list_head, len: size_t) / { head: AddressType, len: size_t } -> c_long
[INFO] [stdout] 790 | |     ~ [] for [x86_64: 273, aarch64: 99, riscv64: 99, loongarch64: 99, powerpc64: 300, s390x: 304],
[INFO] [stdout]     | |________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 789 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(set_robust_list(head: *mut robust_list_head, len: size_t) / { head: AddressType, len: size_t } -> c_long
[INFO] [stdout] 790 ~     ~ [] for [x86_64: 273, aarch64: 99, riscv64: 99, loongarch64: 99, powerpc64: 300, s390x: 304)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:791:3
[INFO] [stdout]     |
[INFO] [stdout] 791 |   set_thread_area(u_info: *mut user_desc) / { u_info: user_desc } -> c_int ~ [] for [x86_64: 205],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 791 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(set_thread_area(u_info: *mut user_desc) / { u_info: user_desc } -> c_int ~ [] for [x86_64: 205)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                              +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:792:3
[INFO] [stdout]     |
[INFO] [stdout] 792 |   set_tid_address(tidptr: *mut c_int) / { tidptr: AddressType } -> pid_t ~ [] for [x86_64: 218, aarch64: 96, riscv64: 96, loongarch64: 96, powerpc64: 232, s390x: 252],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 792 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(set_tid_address(tidptr: *mut c_int) / { tidptr: AddressType } -> pid_t ~ [] for [x86_64: 218, aarch64: 96, riscv64: 96, loongarch64: 96, powerpc64: 232, s390x: 252)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                                                   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:794:3
[INFO] [stdout]     |
[INFO] [stdout] 794 |   setdomainname(name: *const c_char, len: size_t) / { name: CString } -> c_int ~ [] for [x86_64: 171, aarch64: 162, riscv64: 162, loongarch64: 162, powerpc64: 121, s390x: 121],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 794 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(setdomainname(name: *const c_char, len: size_t) / { name: CString } -> c_int ~ [] for [x86_64: 171, aarch64: 162, riscv64: 162, loongarch64: 162, powerpc64: 121, s390x: 121)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                                                            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:806:3
[INFO] [stdout]     |
[INFO] [stdout] 806 | /   sethostname(name: *const c_char, len: size_t) / { name: CString, len: size_t } -> c_int
[INFO] [stdout] 807 | |     ~ [] for [x86_64: 170, aarch64: 161, riscv64: 161, loongarch64: 161, powerpc64: 74, s390x: 74],
[INFO] [stdout]     | |_________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 806 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(sethostname(name: *const c_char, len: size_t) / { name: CString, len: size_t } -> c_int
[INFO] [stdout] 807 ~     ~ [] for [x86_64: 170, aarch64: 161, riscv64: 161, loongarch64: 161, powerpc64: 74, s390x: 74)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:808:3
[INFO] [stdout]     |
[INFO] [stdout] 808 | /   setitimer(which: c_int, new_value: *const itimerval, old_value: *mut itimerval) /
[INFO] [stdout] 809 | |     { which: c_int, new_value: itimerval, old_value: Option<itimerval> } -> c_int
[INFO] [stdout] 810 | |     ~ [] for [x86_64: 38, aarch64: 103, riscv64: 103, loongarch64: 103, powerpc64: 104, s390x: 104],
[INFO] [stdout]     | |__________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 808 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(setitimer(which: c_int, new_value: *const itimerval, old_value: *mut itimerval) /
[INFO] [stdout] 809 |     { which: c_int, new_value: itimerval, old_value: Option<itimerval> } -> c_int
[INFO] [stdout] 810 ~     ~ [] for [x86_64: 38, aarch64: 103, riscv64: 103, loongarch64: 103, powerpc64: 104, s390x: 104)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:812:3
[INFO] [stdout]     |
[INFO] [stdout] 812 |   setpgid(pid: pid_t, pgid: pid_t) / { pid: pid_t, pgid: pid_t } -> c_int ~ [] for [x86_64: 109, aarch64: 154, riscv64: 154, loongarch64: 154, powerpc64: 57, s390x: 57],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 812 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(setpgid(pid: pid_t, pgid: pid_t) / { pid: pid_t, pgid: pid_t } -> c_int ~ [] for [x86_64: 109, aarch64: 154, riscv64: 154, loongarch64: 154, powerpc64: 57, s390x: 57)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                                                     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:814:3
[INFO] [stdout]     |
[INFO] [stdout] 814 | /   setpriority(which: c_int, who: id_t, prio: c_int) / { which: c_int, who: id_t, prio: c_int } -> c_int
[INFO] [stdout] 815 | |     ~ [] for [x86_64: 141, aarch64: 140, riscv64: 140, loongarch64: 140, powerpc64: 97, s390x: 97],
[INFO] [stdout]     | |_________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 814 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(setpriority(which: c_int, who: id_t, prio: c_int) / { which: c_int, who: id_t, prio: c_int } -> c_int
[INFO] [stdout] 815 ~     ~ [] for [x86_64: 141, aarch64: 140, riscv64: 140, loongarch64: 140, powerpc64: 97, s390x: 97)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:826:3
[INFO] [stdout]     |
[INFO] [stdout] 826 | /   setrlimit(resource: c_int, rlim: *const rlimit) / { resource: c_int, rlim: rlimit } -> c_int
[INFO] [stdout] 827 | |     ~ [] for [x86_64: 160, aarch64: 164, riscv64: 164, powerpc64: 75, s390x: 75],
[INFO] [stdout]     | |_______________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 826 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(setrlimit(resource: c_int, rlim: *const rlimit) / { resource: c_int, rlim: rlimit } -> c_int
[INFO] [stdout] 827 ~     ~ [] for [x86_64: 160, aarch64: 164, riscv64: 164, powerpc64: 75, s390x: 75)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:828:3
[INFO] [stdout]     |
[INFO] [stdout] 828 |   setsid() / {} -> pid_t ~ [] for [x86_64: 112, aarch64: 157, riscv64: 157, loongarch64: 157, powerpc64: 66, s390x: 66],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 828 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(setsid() / {} -> pid_t ~ [] for [x86_64: 112, aarch64: 157, riscv64: 157, loongarch64: 157, powerpc64: 66, s390x: 66)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:839:3
[INFO] [stdout]     |
[INFO] [stdout] 839 | /   setxattrat(dfd: RawFd, pathname: *const c_char, at_flags: c_uint, name: *const c_char, uargs: *const c_void, r#usize: size_t) /
[INFO] [stdout] 840 | |     { dfd: RawFd, pathname: PathBuf, at_flags: c_uint, name: CString, uargs: Arc<xattr_args> @ sized_by(raw_args.r#usize) } -> c_int
[INFO] [stdout] 841 | |     ~ [File, Desc] for [x86_64: 463, aarch64: 463, riscv64: 463, loongarch64: 463, powerpc64: 463, s390x: 463],
[INFO] [stdout]     | |_____________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 839 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(setxattrat(dfd: RawFd, pathname: *const c_char, at_flags: c_uint, name: *const c_char, uargs: *const c_void, r#usize: size_t) /
[INFO] [stdout] 840 |     { dfd: RawFd, pathname: PathBuf, at_flags: c_uint, name: CString, uargs: Arc<xattr_args> @ sized_by(raw_args.r#usize) } -> c_int
[INFO] [stdout] 841 ~     ~ [File, Desc] for [x86_64: 463, aarch64: 463, riscv64: 463, loongarch64: 463, powerpc64: 463, s390x: 463)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:843:3
[INFO] [stdout]     |
[INFO] [stdout] 843 | /   shmat(shmid: c_int, shmaddr: *const c_void, shmflg: c_int) / { shmid: c_int, shmaddr: AddressType, shmflg: c_int } -> AddressType
[INFO] [stdout] 844 | |     ~ [IPC, Memory] for [x86_64: 30, aarch64: 196, riscv64: 196, loongarch64: 196, powerpc64: 397, s390x: 397],
[INFO] [stdout]     | |_____________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 843 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(shmat(shmid: c_int, shmaddr: *const c_void, shmflg: c_int) / { shmid: c_int, shmaddr: AddressType, shmflg: c_int } -> AddressType
[INFO] [stdout] 844 ~     ~ [IPC, Memory] for [x86_64: 30, aarch64: 196, riscv64: 196, loongarch64: 196, powerpc64: 397, s390x: 397)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:847:3
[INFO] [stdout]     |
[INFO] [stdout] 847 |   shmdt(shmaddr: *const c_void) / { shmaddr: AddressType } -> c_int ~ [IPC, Memory] for [x86_64: 67, aarch64: 197, riscv64: 197, loongarch64: 197, powerpc64: 398, s390x: 398],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 847 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(shmdt(shmaddr: *const c_void) / { shmaddr: AddressType } -> c_int ~ [IPC, Memory] for [x86_64: 67, aarch64: 197, riscv64: 197, loongarch64: 197, powerpc64: 398, s390x: 398)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                                                           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:855:3
[INFO] [stdout]     |
[INFO] [stdout] 855 | /   signalfd(fd: RawFd, mask: *const sigset_t, size: size_t) / { fd: RawFd, mask: sigset_t, size: size_t } -> c_int
[INFO] [stdout] 856 | |     ~ [Desc, Signal] for [x86_64: 282, powerpc64: 305, s390x: 316],
[INFO] [stdout]     | |_________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 855 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(signalfd(fd: RawFd, mask: *const sigset_t, size: size_t) / { fd: RawFd, mask: sigset_t, size: size_t } -> c_int
[INFO] [stdout] 856 ~     ~ [Desc, Signal] for [x86_64: 282, powerpc64: 305, s390x: 316)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:857:3
[INFO] [stdout]     |
[INFO] [stdout] 857 | /   signalfd4(fd: RawFd, mask: *const sigset_t, size: size_t, flags: c_int) / { fd: RawFd, mask: sigset_t, size: size_t, flags: c_i...
[INFO] [stdout] 858 | |     ~ [Desc, Signal] for [x86_64: 289, aarch64: 74, riscv64: 74, loongarch64: 74, powerpc64: 313, s390x: 322],
[INFO] [stdout]     | |____________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 857 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(signalfd4(fd: RawFd, mask: *const sigset_t, size: size_t, flags: c_int) / { fd: RawFd, mask: sigset_t, size: size_t, flags: c_int } -> c_int
[INFO] [stdout] 858 ~     ~ [Desc, Signal] for [x86_64: 289, aarch64: 74, riscv64: 74, loongarch64: 74, powerpc64: 313, s390x: 322)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:875:3
[INFO] [stdout]     |
[INFO] [stdout] 875 | /   stat(pathname: *const c_char, statbuf: *mut stat) / { pathname: PathBuf } -> c_int + { statbuf: stat }
[INFO] [stdout] 876 | |     ~ [File, Stat, StatLike] for [x86_64: 4, powerpc64: 106, s390x: 106],
[INFO] [stdout]     | |_______________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 875 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(stat(pathname: *const c_char, statbuf: *mut stat) / { pathname: PathBuf } -> c_int + { statbuf: stat }
[INFO] [stdout] 876 ~     ~ [File, Stat, StatLike] for [x86_64: 4, powerpc64: 106, s390x: 106)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:878:3
[INFO] [stdout]     |
[INFO] [stdout] 878 | /   statfs(path: *const c_char, buf: *mut statfs) / { path: PathBuf } -> c_int + { buf: statfs }
[INFO] [stdout] 879 | |     ~ [File, StatFs, StatFsLike] for [x86_64: 137, aarch64: 43, riscv64: 43, loongarch64: 43, powerpc64: 99, s390x: 99],
[INFO] [stdout]     | |______________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 878 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(statfs(path: *const c_char, buf: *mut statfs) / { path: PathBuf } -> c_int + { buf: statfs }
[INFO] [stdout] 879 ~     ~ [File, StatFs, StatFsLike] for [x86_64: 137, aarch64: 43, riscv64: 43, loongarch64: 43, powerpc64: 99, s390x: 99)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:882:3
[INFO] [stdout]     |
[INFO] [stdout] 882 | /   statmount(req: *const mnt_id_req, buf: *mut c_void, bufsize: size_t, flags: c_uint) /
[INFO] [stdout] 883 | |     { req: mnt_id_req, bufsize: size_t, flags: c_uint } -> c_int + { buf: Arc<statmount> @ sized_by(raw_args.bufsize) }
[INFO] [stdout] 884 | |     ~ [] for [x86_64: 457, aarch64: 457, riscv64: 457, loongarch64: 457, powerpc64: 457, s390x: 457],
[INFO] [stdout]     | |___________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 882 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(statmount(req: *const mnt_id_req, buf: *mut c_void, bufsize: size_t, flags: c_uint) /
[INFO] [stdout] 883 |     { req: mnt_id_req, bufsize: size_t, flags: c_uint } -> c_int + { buf: Arc<statmount> @ sized_by(raw_args.bufsize) }
[INFO] [stdout] 884 ~     ~ [] for [x86_64: 457, aarch64: 457, riscv64: 457, loongarch64: 457, powerpc64: 457, s390x: 457)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:885:3
[INFO] [stdout]     |
[INFO] [stdout] 885 | /   statx(dirfd: RawFd, pathname: *const c_char, flags: c_int, mask: c_uint, statxbuf: *mut statx) /
[INFO] [stdout] 886 | |     { dirfd: RawFd, pathname: PathBuf, flags: c_int, mask: c_uint } -> c_int + { statxbuf: statx }
[INFO] [stdout] 887 | |     ~ [Desc, File, FStat, StatLike] for [x86_64: 332, aarch64: 291, riscv64: 291, loongarch64: 291, powerpc64: 383, s390x: 379],
[INFO] [stdout]     | |______________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 885 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(statx(dirfd: RawFd, pathname: *const c_char, flags: c_int, mask: c_uint, statxbuf: *mut statx) /
[INFO] [stdout] 886 |     { dirfd: RawFd, pathname: PathBuf, flags: c_int, mask: c_uint } -> c_int + { statxbuf: statx }
[INFO] [stdout] 887 ~     ~ [Desc, File, FStat, StatLike] for [x86_64: 332, aarch64: 291, riscv64: 291, loongarch64: 291, powerpc64: 383, s390x: 379)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:897:3
[INFO] [stdout]     |
[INFO] [stdout] 897 | /   symlinkat(target: *const c_char, newdirfd: RawFd, linkpath: *const c_char) /
[INFO] [stdout] 898 | |     { target: PathBuf, newdirfd: RawFd, linkpath: PathBuf } -> c_int
[INFO] [stdout] 899 | |     ~ [Desc, File] for [x86_64: 266, aarch64: 36, riscv64: 36, loongarch64: 36, powerpc64: 295, s390x: 297],
[INFO] [stdout]     | |__________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 897 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(symlinkat(target: *const c_char, newdirfd: RawFd, linkpath: *const c_char) /
[INFO] [stdout] 898 |     { target: PathBuf, newdirfd: RawFd, linkpath: PathBuf } -> c_int
[INFO] [stdout] 899 ~     ~ [Desc, File] for [x86_64: 266, aarch64: 36, riscv64: 36, loongarch64: 36, powerpc64: 295, s390x: 297)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:901:3
[INFO] [stdout]     |
[INFO] [stdout] 901 |   sync() / {} -> c_int ~ [] for [x86_64: 162, aarch64: 81, riscv64: 81, loongarch64: 81, powerpc64: 36, s390x: 36],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 901 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(sync() / {} -> c_int ~ [] for [x86_64: 162, aarch64: 81, riscv64: 81, loongarch64: 81, powerpc64: 36, s390x: 36)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                               +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:909:3
[INFO] [stdout]     |
[INFO] [stdout] 909 | /   sysfs(option: c_int, arg1: c_ulong, arg2: c_ulong) / { option: c_int, arg1: c_ulong, arg2: c_ulong } -> c_int
[INFO] [stdout] 910 | |     ~ [] for [x86_64: 139, powerpc64: 135, s390x: 135],
[INFO] [stdout]     | |_____________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 909 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(sysfs(option: c_int, arg1: c_ulong, arg2: c_ulong) / { option: c_int, arg1: c_ulong, arg2: c_ulong } -> c_int
[INFO] [stdout] 910 ~     ~ [] for [x86_64: 139, powerpc64: 135, s390x: 135)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:911:3
[INFO] [stdout]     |
[INFO] [stdout] 911 |   sysinfo(info: *mut sysinfo) / { } -> c_int + { info: sysinfo } ~ [] for [x86_64: 99, aarch64: 179, riscv64: 179, loongarch64: 179, powerpc64: 116, s390x: 116],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 911 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(sysinfo(info: *mut sysinfo) / { } -> c_int + { info: sysinfo } ~ [] for [x86_64: 99, aarch64: 179, riscv64: 179, loongarch64: 179, powerpc64: 116, s390x: 116)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                                             +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:912:3
[INFO] [stdout]     |
[INFO] [stdout] 912 | /   syslog(typ: c_int, buf: *const c_char, len: c_int) / { typ: c_int, buf: CString, len: c_int } -> c_int
[INFO] [stdout] 913 | |     ~ [] for [x86_64: 103, aarch64: 116, riscv64: 116, loongarch64: 116, powerpc64: 103, s390x: 103],
[INFO] [stdout]     | |___________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 912 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(syslog(typ: c_int, buf: *const c_char, len: c_int) / { typ: c_int, buf: CString, len: c_int } -> c_int
[INFO] [stdout] 913 ~     ~ [] for [x86_64: 103, aarch64: 116, riscv64: 116, loongarch64: 116, powerpc64: 103, s390x: 103)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:917:3
[INFO] [stdout]     |
[INFO] [stdout] 917 | /   tgkill(tgid: pid_t, tid: pid_t, sig: c_int) / { tgid: pid_t, tid: pid_t, sig: c_int } -> c_int
[INFO] [stdout] 918 | |     ~ [Signal, Process] for [x86_64: 234, aarch64: 131, riscv64: 131, loongarch64: 131, powerpc64: 250, s390x: 241],
[INFO] [stdout]     | |__________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 917 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(tgkill(tgid: pid_t, tid: pid_t, sig: c_int) / { tgid: pid_t, tid: pid_t, sig: c_int } -> c_int
[INFO] [stdout] 918 ~     ~ [Signal, Process] for [x86_64: 234, aarch64: 131, riscv64: 131, loongarch64: 131, powerpc64: 250, s390x: 241)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:920:3
[INFO] [stdout]     |
[INFO] [stdout] 920 | /   timer_create(clockid: clockid_t, sevp: *const sigevent, timerid: *mut timer_t) /
[INFO] [stdout] 921 | |     { clockid: clockid_t, sevp: Option<sigevent> } -> c_int + { timerid: InspectResult<timer_t> }
[INFO] [stdout] 922 | |     ~ [] for [x86_64: 222, aarch64: 107, riscv64: 107, loongarch64: 107, powerpc64: 240, s390x: 254],
[INFO] [stdout]     | |___________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 920 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(timer_create(clockid: clockid_t, sevp: *const sigevent, timerid: *mut timer_t) /
[INFO] [stdout] 921 |     { clockid: clockid_t, sevp: Option<sigevent> } -> c_int + { timerid: InspectResult<timer_t> }
[INFO] [stdout] 922 ~     ~ [] for [x86_64: 222, aarch64: 107, riscv64: 107, loongarch64: 107, powerpc64: 240, s390x: 254)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:923:3
[INFO] [stdout]     |
[INFO] [stdout] 923 |   timer_delete(timerid: timer_t) / { timerid: timer_t } -> c_int ~ [] for [x86_64: 226, aarch64: 111, riscv64: 111, loongarch64: 111, powerpc64: 244, s390x: 258],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 923 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(timer_delete(timerid: timer_t) / { timerid: timer_t } -> c_int ~ [] for [x86_64: 226, aarch64: 111, riscv64: 111, loongarch64: 111, powerpc64: 244, s390x: 258)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                                              +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:924:3
[INFO] [stdout]     |
[INFO] [stdout] 924 |   timer_getoverrun(timerid: timer_t) / { timerid: timer_t } -> c_int ~ [] for [x86_64: 225, aarch64: 109, riscv64: 109, loongarch64: 109, powerpc64: 243, s390x: 257],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 924 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(timer_getoverrun(timerid: timer_t) / { timerid: timer_t } -> c_int ~ [] for [x86_64: 225, aarch64: 109, riscv64: 109, loongarch64: 109, powerpc64: 243, s390x: 257)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                                                  +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:925:3
[INFO] [stdout]     |
[INFO] [stdout] 925 | /   timer_gettime(timerid: timer_t, curr_value: *mut itimerspec) / { timerid: timer_t } -> c_int + { curr_value: itimerspec }
[INFO] [stdout] 926 | |     ~ [] for [x86_64: 224, aarch64: 108, riscv64: 108, loongarch64: 108, powerpc64: 242, s390x: 256],
[INFO] [stdout]     | |___________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 925 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(timer_gettime(timerid: timer_t, curr_value: *mut itimerspec) / { timerid: timer_t } -> c_int + { curr_value: itimerspec }
[INFO] [stdout] 926 ~     ~ [] for [x86_64: 224, aarch64: 108, riscv64: 108, loongarch64: 108, powerpc64: 242, s390x: 256)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:928:3
[INFO] [stdout]     |
[INFO] [stdout] 928 | /   timer_settime(timerid: timer_t, flags: c_int, new_value: *const itimerspec, old_value: *mut itimerspec) /
[INFO] [stdout] 929 | |     { timerid: timer_t, flags: c_int, new_value: itimerspec } -> c_int + { old_value: Option<itimerspec> }
[INFO] [stdout] 930 | |     ~ [] for [x86_64: 223, aarch64: 110, riscv64: 110, loongarch64: 110, powerpc64: 241, s390x: 255],
[INFO] [stdout]     | |___________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 928 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(timer_settime(timerid: timer_t, flags: c_int, new_value: *const itimerspec, old_value: *mut itimerspec) /
[INFO] [stdout] 929 |     { timerid: timer_t, flags: c_int, new_value: itimerspec } -> c_int + { old_value: Option<itimerspec> }
[INFO] [stdout] 930 ~     ~ [] for [x86_64: 223, aarch64: 110, riscv64: 110, loongarch64: 110, powerpc64: 241, s390x: 255)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:942:3
[INFO] [stdout]     |
[INFO] [stdout] 942 |   times(buf: *mut tms) / { } -> clock_t + { buf: tms } ~ [] for [x86_64: 100, aarch64: 153, riscv64: 153, loongarch64: 153, powerpc64: 43, s390x: 43],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 942 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(times(buf: *mut tms) / { } -> clock_t + { buf: tms } ~ [] for [x86_64: 100, aarch64: 153, riscv64: 153, loongarch64: 153, powerpc64: 43, s390x: 43)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                                  +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:943:3
[INFO] [stdout]     |
[INFO] [stdout] 943 |   tkill(tid: pid_t, sig: c_int) / { tid: pid_t, sig: c_int } -> c_int ~ [Signal, Process] for [x86_64: 200, aarch64: 130, riscv64: 130, loongarch64: 130, powerpc64: 208, s390x: 237],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 943 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(tkill(tid: pid_t, sig: c_int) / { tid: pid_t, sig: c_int } -> c_int ~ [Signal, Process] for [x86_64: 200, aarch64: 130, riscv64: 130, loongarch64: 130, powerpc64: 208, s390x: 237)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                                                                  +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:948:3
[INFO] [stdout]     |
[INFO] [stdout] 948 |   umask(mask: mode_t) / { mask: mode_t } -> mode_t ~ [] for [x86_64: 95, aarch64: 166, riscv64: 166, loongarch64: 166, powerpc64: 60, s390x: 60],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 948 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(umask(mask: mode_t) / { mask: mode_t } -> mode_t ~ [] for [x86_64: 95, aarch64: 166, riscv64: 166, loongarch64: 166, powerpc64: 60, s390x: 60)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                             +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:952:3
[INFO] [stdout]     |
[INFO] [stdout] 952 |   uname(buf: *mut utsname) / { } -> c_int + { buf: utsname } ~ [] for [x86_64: 63, aarch64: 160, riscv64: 160, loongarch64: 160, powerpc64: 122, s390x: 122],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 952 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(uname(buf: *mut utsname) / { } -> c_int + { buf: utsname } ~ [] for [x86_64: 63, aarch64: 160, riscv64: 160, loongarch64: 160, powerpc64: 122, s390x: 122)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                                         +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:954:3
[INFO] [stdout]     |
[INFO] [stdout] 954 | /   unlinkat(dirfd: RawFd, pathname: *const c_char, flags: c_int) / { dirfd: RawFd, pathname: PathBuf, flags: c_int } -> c_int
[INFO] [stdout] 955 | |     ~ [Desc, File] for [x86_64: 263, aarch64: 35, riscv64: 35, loongarch64: 35, powerpc64: 292, s390x: 294],
[INFO] [stdout]     | |__________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 954 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(unlinkat(dirfd: RawFd, pathname: *const c_char, flags: c_int) / { dirfd: RawFd, pathname: PathBuf, flags: c_int } -> c_int
[INFO] [stdout] 955 ~     ~ [Desc, File] for [x86_64: 263, aarch64: 35, riscv64: 35, loongarch64: 35, powerpc64: 292, s390x: 294)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:956:3
[INFO] [stdout]     |
[INFO] [stdout] 956 |   unshare(flags: c_int) / { flags: c_int } -> c_int ~ [] for [x86_64: 272, aarch64: 97, riscv64: 97, loongarch64: 97, powerpc64: 282, s390x: 303],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 956 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(unshare(flags: c_int) / { flags: c_int } -> c_int ~ [] for [x86_64: 272, aarch64: 97, riscv64: 97, loongarch64: 97, powerpc64: 282, s390x: 303)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                              +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:957:3
[INFO] [stdout]     |
[INFO] [stdout] 957 |   uprobe() / {} -> c_int ~ [] for [x86_64: 336],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 957 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(uprobe() / {} -> c_int ~ [] for [x86_64: 336)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:958:3
[INFO] [stdout]     |
[INFO] [stdout] 958 |   uretprobe() / { } -> c_int ~ [] for [x86_64: 335],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 958 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(uretprobe() / { } -> c_int ~ [] for [x86_64: 335)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:960:3
[INFO] [stdout]     |
[INFO] [stdout] 960 |   ustat(dev: dev_t, ubuf: *mut ustat) / { dev: dev_t } -> c_int + { ubuf: ustat } ~ [] for [x86_64: 136, powerpc64: 62, s390x: 62],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 960 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(ustat(dev: dev_t, ubuf: *mut ustat) / { dev: dev_t } -> c_int + { ubuf: ustat } ~ [] for [x86_64: 136, powerpc64: 62, s390x: 62)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                               +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:963:3
[INFO] [stdout]     |
[INFO] [stdout] 963 | /   utimensat(dirfd: RawFd, pathname: *const c_char, times: *const timespec, flags: c_int) /
[INFO] [stdout] 964 | |     { dirfd: RawFd, pathname: PathBuf, times: Option<[timespec; 2]>, flags: c_int } -> c_int
[INFO] [stdout] 965 | |     ~ [Desc, File] for [x86_64: 280, aarch64: 88, riscv64: 88, loongarch64: 88, powerpc64: 304, s390x: 315],
[INFO] [stdout]     | |__________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 963 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(utimensat(dirfd: RawFd, pathname: *const c_char, times: *const timespec, flags: c_int) /
[INFO] [stdout] 964 |     { dirfd: RawFd, pathname: PathBuf, times: Option<[timespec; 2]>, flags: c_int } -> c_int
[INFO] [stdout] 965 ~     ~ [Desc, File] for [x86_64: 280, aarch64: 88, riscv64: 88, loongarch64: 88, powerpc64: 304, s390x: 315)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>`
[INFO] [stdout]    --> src/syscalls.rs:971:3
[INFO] [stdout]     |
[INFO] [stdout] 971 |   vhangup() / {} -> c_int ~ [] for [x86_64: 153, aarch64: 58, riscv64: 58, loongarch64: 58, powerpc64: 111, s390x: 111],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 971 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(vhangup() / {} -> c_int ~ [] for [x86_64: 153, aarch64: 58, riscv64: 58, loongarch64: 58, powerpc64: 111, s390x: 111)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `ptrace-syscalls` (lib) due to 159 previous errors; 1 warning emitted
[INFO] [stderr] warning: unused dependency `itertools`
[INFO] [stderr]  --> Cargo.toml:4:1
[INFO] [stderr]   |
[INFO] [stderr] 4 | itertools = "0.13.0"
[INFO] [stderr]   | ^^^^^^^^^^^^^^^^^^^^
[INFO] [stderr]   |
[INFO] [stderr]   = note: `cargo::unused_dependencies` is set to `warn` by default
[INFO] [stderr] help: consider removing the dependency on `itertools`
[INFO] [stderr] warning: `ptrace-syscalls` (manifest) generated 1 warning
[INFO] running `Command { std: "docker" "inspect" "805444b328cd7735e6182cf170aaa2ea0a5063d5bd3ab7a6042839bfd4fcbe7a", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "805444b328cd7735e6182cf170aaa2ea0a5063d5bd3ab7a6042839bfd4fcbe7a", kill_on_drop: false }`
[INFO] [stdout] 805444b328cd7735e6182cf170aaa2ea0a5063d5bd3ab7a6042839bfd4fcbe7a
