[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] 314e880f16e46ebf449847a942ee6fb722789d9c
[INFO] checking kxxt/ptrace-syscalls against c60b92c03ca8a3b101eb9d57f51e2232690638c7 for pr-164148-crater-rollup
[INFO] running `Command { std: "git" "clone" "/workspace/cache/git-repos/https%3A%2F%2Fgithub.com%2Fkxxt%2Fptrace-syscalls" "/workspace/builds/worker-3-tc2/source", kill_on_drop: false }`
[INFO] [stderr] Cloning into '/workspace/builds/worker-3-tc2/source'...
[INFO] [stderr] done.
[INFO] started tweaking git repo https://github.com/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-3-tc2/source/Cargo.toml
[INFO] validating manifest of git repo https://github.com/kxxt/ptrace-syscalls on toolchain c60b92c03ca8a3b101eb9d57f51e2232690638c7
[INFO] running `Command { std: CARGO_HOME="/workspace/cargo-home" RUSTUP_HOME="/workspace/rustup-home" "/workspace/cargo-home/bin/cargo" "+c60b92c03ca8a3b101eb9d57f51e2232690638c7" "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" "+c60b92c03ca8a3b101eb9d57f51e2232690638c7" "fetch" "--manifest-path" "Cargo.toml", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "create" "-v" "/var/lib/crater-agent-workspace/builds/worker-3-tc2/source:/opt/rustwide/workdir:ro,Z" "-v" "/var/lib/crater-agent-workspace/builds/worker-3-tc2/target:/opt/rustwide/target:rw,Z" "-v" "/var/lib/crater-agent-workspace/cargo-home:/opt/rustwide/cargo-home:ro,Z" "-v" "/var/lib/crater-agent-workspace/rustup-home:/opt/rustwide/rustup-home:ro,Z" "-m" "1610612736" "--network" "none" "ghcr.io/rust-lang/crates-build-env/linux@sha256:77db811e55d90add9212f6832c23229e3de5f1c1f9905e8cb07319ea15df73ac" "sleep" "infinity", kill_on_drop: false }`
[INFO] [stdout] fe4508345f6379c155a6309f301ad3dfd3c92b321dec73293c250be96e8a494b
[INFO] running `Command { std: "docker" "start" "fe4508345f6379c155a6309f301ad3dfd3c92b321dec73293c250be96e8a494b", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "fe4508345f6379c155a6309f301ad3dfd3c92b321dec73293c250be96e8a494b", 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" "fe4508345f6379c155a6309f301ad3dfd3c92b321dec73293c250be96e8a494b" "/opt/rustwide/cargo-home/bin/cargo" "+c60b92c03ca8a3b101eb9d57f51e2232690638c7" "metadata" "--no-deps" "--format-version=1", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "inspect" "fe4508345f6379c155a6309f301ad3dfd3c92b321dec73293c250be96e8a494b", 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" "fe4508345f6379c155a6309f301ad3dfd3c92b321dec73293c250be96e8a494b" "/opt/rustwide/cargo-home/bin/cargo" "+c60b92c03ca8a3b101eb9d57f51e2232690638c7" "check" "--frozen" "--all" "--all-targets" "--message-format=json", kill_on_drop: false }`
[INFO] [stderr]    Compiling proc-macro2 v1.0.101
[INFO] [stderr]    Compiling indexmap v2.11.0
[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]    Compiling convert_case v0.6.0
[INFO] [stderr]     Checking hashbrown v0.15.5
[INFO] [stderr]     Checking equivalent v1.0.2
[INFO] [stderr]     Checking unicode-ident v1.0.18
[INFO] [stderr]     Checking kxxt-owo-colors v4.0.0
[INFO] [stderr]    Compiling quote v1.0.40
[INFO] [stderr]     Checking toml_datetime v0.6.11
[INFO] [stderr]    Compiling toml_edit v0.22.27
[INFO] [stderr]     Checking winnow v0.7.13
[INFO] [stderr]    Compiling syn v2.0.106
[INFO] [stderr]     Checking unicode-segmentation v1.12.0
[INFO] [stderr]    Compiling proc-macro-crate v3.3.0
[INFO] [stderr]    Compiling enumflags2_derive v0.7.12
[INFO] [stderr]    Compiling 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:332:4
[INFO] [stdout]     |
[INFO] [stdout] 332 | 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] warning: function `read_lossy_string` is never used
[INFO] [stdout]    --> src/inspect.rs:332:4
[INFO] [stdout]     |
[INFO] [stdout] 332 | 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>` ptrace_syscalls
[INFO] [stdout]   --> src/syscalls.rs:78:3
[INFO] [stdout]    |
[INFO] [stdout] 78 | /   add_key(r#type: *const c_char, description: *const c_char, payload: *const c_void, plen: size_t, keyring: key_serial_t ) /
[INFO] [stdout] 79 | |     { r#type: CString, description: CString, payload: Vec<u8> @ counted_by(raw_args.plen), keyring: key_serial_t }
[INFO] [stdout] 80 | |     -> key_serial_t ~ [] for [x86_64: 248, aarch64: 217, riscv64: 217],
[INFO] [stdout]    | |_____________________________________________________________________^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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] 78 ~   <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] 79 |     { r#type: CString, description: CString, payload: Vec<u8> @ counted_by(raw_args.plen), keyring: key_serial_t }
[INFO] [stdout] 80 ~     -> key_serial_t ~ [] for [x86_64: 248, aarch64: 217, riscv64: 217)],
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]   --> src/syscalls.rs:82:3
[INFO] [stdout]    |
[INFO] [stdout] 82 |   alarm(seconds: c_uint) / { seconds: c_uint } -> c_uint ~ [] for [x86_64: 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] 82 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(alarm(seconds: c_uint) / { seconds: c_uint } -> c_uint ~ [] for [x86_64: 37)],
[INFO] [stdout]    |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]   --> src/syscalls.rs:84:3
[INFO] [stdout]    |
[INFO] [stdout] 84 |   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] 84 |   <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>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:115:3
[INFO] [stdout]     |
[INFO] [stdout] 115 | /   clock_nanosleep(clockid: clockid_t, flags: c_int, request: *const timespec, remain: *mut timespec) /
[INFO] [stdout] 116 | |   { clockid: clockid_t, flags: c_int, request: timespec } -> c_int + { remain: Option<timespec> }
[INFO] [stdout] 117 | |     ~ [] for [x86_64: 230, aarch64: 115, riscv64: 115],
[INFO] [stdout]     | |_____________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 115 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(clock_nanosleep(clockid: clockid_t, flags: c_int, request: *const timespec, remain: *mut timespec) /
[INFO] [stdout] 116 |   { clockid: clockid_t, flags: c_int, request: timespec } -> c_int + { remain: Option<timespec> }
[INFO] [stdout] 117 ~     ~ [] for [x86_64: 230, aarch64: 115, riscv64: 115)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:131:3
[INFO] [stdout]     |
[INFO] [stdout] 131 | /   close_range(first: c_uint, last: c_uint, flags: c_uint) / { first: c_uint, last: c_uint, flags: c_uint }
[INFO] [stdout] 132 | |     -> c_int ~ [] for [x86_64: 436, aarch64: 436, riscv64: 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] 131 ~   <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] 132 ~     -> c_int ~ [] for [x86_64: 436, aarch64: 436, riscv64: 436)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:138:3
[INFO] [stdout]     |
[INFO] [stdout] 138 |   creat(pathname: *const c_char, mode: mode_t) / { pathname: PathBuf, mode: mode_t } -> RawFd ~ [Desc, File] for [x86_64: 85],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 138 |   <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)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                          +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:139:3
[INFO] [stdout]     |
[INFO] [stdout] 139 |   delete_module(name: *const c_char, flags: c_uint) / { name: CString, flags: c_uint } -> c_int ~ [] for [x86_64: 176, aarch64: 106, riscv64: 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] 139 |   <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)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                               +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:167:3
[INFO] [stdout]     |
[INFO] [stdout] 167 | /   execve(filename: *const c_char, argv: *const *const c_char, envp: *const *const c_char) /
[INFO] [stdout] 168 | |     { filename: PathBuf, argv: Option<Vec<CString>>, envp: Option<Vec<CString>> } -> c_int
[INFO] [stdout] 169 | |     ~ [File, Process] for [x86_64: 59, aarch64: 221, riscv64: 221],
[INFO] [stdout]     | |_________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 167 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(execve(filename: *const c_char, argv: *const *const c_char, envp: *const *const c_char) /
[INFO] [stdout] 168 |     { filename: PathBuf, argv: Option<Vec<CString>>, envp: Option<Vec<CString>> } -> c_int
[INFO] [stdout] 169 ~     ~ [File, Process] for [x86_64: 59, aarch64: 221, riscv64: 221)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:170:3
[INFO] [stdout]     |
[INFO] [stdout] 170 | /   execveat(dirfd: RawFd, pathname: *const c_char, argv: *const *const c_char, envp: *const *const c_char, flags: c_int) /
[INFO] [stdout] 171 | |     { dirfd: RawFd, pathname: PathBuf, argv: Option<Vec<CString>>, envp: Option<Vec<CString>>, flags: c_int }
[INFO] [stdout] 172 | |     -> c_int ~ [Desc, File, Process] for [x86_64: 322, aarch64: 281, riscv64: 281],
[INFO] [stdout]     | |_________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 170 ~   <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] 171 |     { dirfd: RawFd, pathname: PathBuf, argv: Option<Vec<CString>>, envp: Option<Vec<CString>>, flags: c_int }
[INFO] [stdout] 172 ~     -> c_int ~ [Desc, File, Process] for [x86_64: 322, aarch64: 281, riscv64: 281)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:175:3
[INFO] [stdout]     |
[INFO] [stdout] 175 | /   faccessat(dirfd: RawFd, pathname: *const c_char, mode: c_int) /
[INFO] [stdout] 176 | |     { dirfd: RawFd, pathname: PathBuf, mode: c_int } -> c_int ~ [Desc, File] for [x86_64: 269, aarch64: 48, riscv64: 48],
[INFO] [stdout]     | |_______________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 175 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(faccessat(dirfd: RawFd, pathname: *const c_char, mode: c_int) /
[INFO] [stdout] 176 ~     { dirfd: RawFd, pathname: PathBuf, mode: c_int } -> c_int ~ [Desc, File] for [x86_64: 269, aarch64: 48, riscv64: 48)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:177:3
[INFO] [stdout]     |
[INFO] [stdout] 177 | /   faccessat2(dirfd: RawFd, pathname: *const c_char, mode: c_int, flags: c_int) /
[INFO] [stdout] 178 | |     { dirfd: RawFd, pathname: PathBuf, mode: c_int, flags: c_int } -> c_int ~ [Desc, File] for [x86_64: 439, aarch64: 439, riscv64: 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] 177 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(faccessat2(dirfd: RawFd, pathname: *const c_char, mode: c_int, flags: c_int) /
[INFO] [stdout] 178 ~     { dirfd: RawFd, pathname: PathBuf, mode: c_int, flags: c_int } -> c_int ~ [Desc, File] for [x86_64: 439, aarch64: 439, riscv64: 439)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:187:3
[INFO] [stdout]     |
[INFO] [stdout] 187 | /   fanotify_mark(fanotify_fd: RawFd, flags: c_uint, mask: u64, dirfd: RawFd, pathname: *const c_char) /
[INFO] [stdout] 188 | |     { 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],
[INFO] [stdout]     | |__________________________________________________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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(fanotify_mark(fanotify_fd: RawFd, flags: c_uint, mask: u64, dirfd: RawFd, pathname: *const c_char) /
[INFO] [stdout] 188 ~     { 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)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:191:3
[INFO] [stdout]     |
[INFO] [stdout] 191 | /   fchmodat(dirfd: RawFd, pathname: *const c_char, mode: mode_t) /
[INFO] [stdout] 192 | |     { dirfd: RawFd, pathname: PathBuf, mode: mode_t } -> c_int ~ [Desc, File] for [x86_64: 268, aarch64: 53, riscv64: 53],
[INFO] [stdout]     | |________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 191 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(fchmodat(dirfd: RawFd, pathname: *const c_char, mode: mode_t) /
[INFO] [stdout] 192 ~     { dirfd: RawFd, pathname: PathBuf, mode: mode_t } -> c_int ~ [Desc, File] for [x86_64: 268, aarch64: 53, riscv64: 53)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:193:3
[INFO] [stdout]     |
[INFO] [stdout] 193 | /   fchmodat2(dirfd: RawFd, pathname: *const c_char, mode: mode_t, flags: c_int) /
[INFO] [stdout] 194 | |     { dirfd: RawFd, pathname: PathBuf, mode: mode_t, flags: c_int } -> c_int ~ [Desc, File] for [x86_64: 452, aarch64: 452, riscv64: 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] 193 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(fchmodat2(dirfd: RawFd, pathname: *const c_char, mode: mode_t, flags: c_int) /
[INFO] [stdout] 194 ~     { dirfd: RawFd, pathname: PathBuf, mode: mode_t, flags: c_int } -> c_int ~ [Desc, File] for [x86_64: 452, aarch64: 452, riscv64: 452)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:197:3
[INFO] [stdout]     |
[INFO] [stdout] 197 | /   fchownat(dirfd: RawFd, pathname: *const c_char, owner: uid_t, group: gid_t, flags: c_int) /
[INFO] [stdout] 198 | |     { 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],
[INFO] [stdout]     | |____________________________________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 197 ~   <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] 198 ~     { 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)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:212:3
[INFO] [stdout]     |
[INFO] [stdout] 212 | /   fsconfig(fd: RawFd, cmd: c_uint, key: *const c_char, value: *const c_char, aux: c_int) /
[INFO] [stdout] 213 | |     { fd: RawFd, cmd: c_uint, key: CString, value: CString, aux: c_int } -> c_int ~ [Desc, File] for [x86_64: 431, aarch64: 431, riscv64: 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] 212 ~   <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] 213 ~     { fd: RawFd, cmd: c_uint, key: CString, value: CString, aux: c_int } -> c_int ~ [Desc, File] for [x86_64: 431, aarch64: 431, riscv64: 431)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:220:3
[INFO] [stdout]     |
[INFO] [stdout] 220 | /   fspick(dirfd: RawFd, pathname: *const c_char, flags: c_uint) / { dirfd: RawFd, pathname: CString, flags: c_uint } -> c_int
[INFO] [stdout] 221 | |     ~ [Desc, File] for [x86_64: 433, aarch64: 433, riscv64: 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] 220 ~   <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] 221 ~     ~ [Desc, File] for [x86_64: 433, aarch64: 433, riscv64: 433)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:222:3
[INFO] [stdout]     |
[INFO] [stdout] 222 |   fstat(fd: RawFd, statbuf: *mut stat) / { fd: RawFd } -> c_int + { statbuf: stat } ~ [Desc, FStat, StatLike] for [x86_64: 5, aarch64: 80, riscv64: 80],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 222 |   <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)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                                    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:224:3
[INFO] [stdout]     |
[INFO] [stdout] 224 |   fstatfs(fd: RawFd, buf: *mut statfs) / { fd: RawFd } -> c_int + { buf: statfs } ~ [Desc, FStatFs, StatFsLike] for [x86_64: 138, aarch64: 44, riscv64: 44],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 224 |   <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)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                                        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:230:3
[INFO] [stdout]     |
[INFO] [stdout] 230 | /   futex(uaddr: *mut u32, futex_op: c_int, val: u32, val2: usize, uaddr2: *mut u32, val3: u32) /
[INFO] [stdout] 231 | |     { uaddr: InspectResult<u32>, futex_op: c_int, val: u32, val2: usize, uaddr2: InspectResult<u32>, val3: u32 }
[INFO] [stdout] 232 | |     -> c_long + { uaddr: InspectResult<u32>, uaddr2: InspectResult<u32> } ~ [] for [x86_64: 202, aarch64: 98, riscv64: 98],
[INFO] [stdout]     | |_________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 230 ~   <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] 231 |     { uaddr: InspectResult<u32>, futex_op: c_int, val: u32, val2: usize, uaddr2: InspectResult<u32>, val3: u32 }
[INFO] [stdout] 232 ~     -> c_long + { uaddr: InspectResult<u32>, uaddr2: InspectResult<u32> } ~ [] for [x86_64: 202, aarch64: 98, riscv64: 98)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:235:3
[INFO] [stdout]     |
[INFO] [stdout] 235 | /   futex_requeue(waiters: *mut futex_waitv, flags: c_uint, nr_wake: c_int, nr_requeue: c_int) /
[INFO] [stdout] 236 | |     { waiters: [futex_waitv; 2], flags: c_uint, nr_wake: c_int, nr_requeue: c_int }
[INFO] [stdout] 237 | |     -> c_long + { waiters: [futex_waitv; 2] } ~ [] for [x86_64: 456, aarch64: 456, riscv64: 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] 235 ~   <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] 236 |     { waiters: [futex_waitv; 2], flags: c_uint, nr_wake: c_int, nr_requeue: c_int }
[INFO] [stdout] 237 ~     -> c_long + { waiters: [futex_waitv; 2] } ~ [] for [x86_64: 456, aarch64: 456, riscv64: 456)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:239:3
[INFO] [stdout]     |
[INFO] [stdout] 239 | /   futex_wait(uaddr: *mut u32, val: c_ulong, mask: c_ulong, flags: c_uint, timespec: *mut timespec, clockid: clockid_t) /
[INFO] [stdout] 240 | |     { uaddr: InspectResult<u32>, val: c_ulong, mask: c_ulong, flags: c_uint, timespec: timespec, clockid: clockid_t }
[INFO] [stdout] 241 | |     -> c_long + { uaddr: InspectResult<u32> } ~ [] for [x86_64: 455, aarch64: 455, riscv64: 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] 239 ~   <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] 240 |     { uaddr: InspectResult<u32>, val: c_ulong, mask: c_ulong, flags: c_uint, timespec: timespec, clockid: clockid_t }
[INFO] [stdout] 241 ~     -> c_long + { uaddr: InspectResult<u32> } ~ [] for [x86_64: 455, aarch64: 455, riscv64: 455)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:242:3
[INFO] [stdout]     |
[INFO] [stdout] 242 | /   futex_waitv(waiters: *mut futex_waitv, nr_futexes: c_uint, flags: c_uint, timeout: *mut timespec, clockid: clockid_t) /
[INFO] [stdout] 243 | |     { waiters: Vec<futex_waitv> @ counted_by(raw_args.nr_futexes), flags: c_uint, timeout: timespec, clockid: clockid_t }
[INFO] [stdout] 244 | |     -> c_long + { waiters: Vec<futex_waitv> @ counted_by(raw_args.nr_futexes) } ~ [] for [x86_64: 449, aarch64: 449, riscv64: 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] 242 ~   <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] 243 |     { waiters: Vec<futex_waitv> @ counted_by(raw_args.nr_futexes), flags: c_uint, timeout: timespec, clockid: clockid_t }
[INFO] [stdout] 244 ~     -> c_long + { waiters: Vec<futex_waitv> @ counted_by(raw_args.nr_futexes) } ~ [] for [x86_64: 449, aarch64: 449, riscv64: 449)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:245:3
[INFO] [stdout]     |
[INFO] [stdout] 245 | /   futex_wake(uaddr: *mut u32, mask: c_ulong, nr: c_int, flags: c_uint) /
[INFO] [stdout] 246 | |     { uaddr: InspectResult<u32>, mask: c_ulong, nr: c_int, flags: c_uint }
[INFO] [stdout] 247 | |     -> c_long + { uaddr: InspectResult<u32> } ~ [] for [x86_64: 454, aarch64: 454, riscv64: 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] 245 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(futex_wake(uaddr: *mut u32, mask: c_ulong, nr: c_int, flags: c_uint) /
[INFO] [stdout] 246 |     { uaddr: InspectResult<u32>, mask: c_ulong, nr: c_int, flags: c_uint }
[INFO] [stdout] 247 ~     -> c_long + { uaddr: InspectResult<u32> } ~ [] for [x86_64: 454, aarch64: 454, riscv64: 454)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:248:3
[INFO] [stdout]     |
[INFO] [stdout] 248 | /   futimesat(dirfd: RawFd, pathname: *const c_char, times: *const timeval) /
[INFO] [stdout] 249 | |     { dirfd: RawFd, pathname: PathBuf, times: [timeval;2] } -> c_int ~ [Desc, File] for [x86_64: 261],
[INFO] [stdout]     | |____________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 248 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(futimesat(dirfd: RawFd, pathname: *const c_char, times: *const timeval) /
[INFO] [stdout] 249 ~     { dirfd: RawFd, pathname: PathBuf, times: [timeval;2] } -> c_int ~ [Desc, File] for [x86_64: 261)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:256:3
[INFO] [stdout]     |
[INFO] [stdout] 256 | /   get_robust_list(pid: pid_t, head_ptr: *mut *mut robust_list_head, len_ptr: *mut size_t) /
[INFO] [stdout] 257 | |     { pid: pid_t, head_ptr: InspectResult<AddressType>, len_ptr: size_t } -> c_long ~ [] for [x86_64: 274, aarch64: 100, riscv64: 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] 256 ~   <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] 257 ~     { pid: pid_t, head_ptr: InspectResult<AddressType>, len_ptr: size_t } -> c_long ~ [] for [x86_64: 274, aarch64: 100, riscv64: 100)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:258:3
[INFO] [stdout]     |
[INFO] [stdout] 258 |   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] 258 |   <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>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:259:3
[INFO] [stdout]     |
[INFO] [stdout] 259 | /   getcpu(cpu: *mut c_uint, node: *mut c_uint) /
[INFO] [stdout] 260 | |     { cpu: InspectResult<Option<c_uint>>, node: InspectResult<Option<c_uint>> } -> c_int ~ [] for [x86_64: 309, aarch64: 168, riscv64: 168],
[INFO] [stdout]     | |__________________________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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(getcpu(cpu: *mut c_uint, node: *mut c_uint) /
[INFO] [stdout] 260 ~     { cpu: InspectResult<Option<c_uint>>, node: InspectResult<Option<c_uint>> } -> c_int ~ [] for [x86_64: 309, aarch64: 168, riscv64: 168)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:271:3
[INFO] [stdout]     |
[INFO] [stdout] 271 |   getegid() / {} -> gid_t ~ [Creds, Pure] for [x86_64: 108, aarch64: 177, riscv64: 177],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 271 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(getegid() / {} -> gid_t ~ [Creds, Pure] for [x86_64: 108, aarch64: 177, riscv64: 177)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:273:3
[INFO] [stdout]     |
[INFO] [stdout] 273 |   geteuid() / {} -> uid_t ~ [Creds, Pure] for [x86_64: 107, aarch64: 175, riscv64: 175],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 273 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(geteuid() / {} -> uid_t ~ [Creds, Pure] for [x86_64: 107, aarch64: 175, riscv64: 175)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:275:3
[INFO] [stdout]     |
[INFO] [stdout] 275 |   getgid() / {} -> gid_t ~ [Creds, Pure] for [x86_64: 104, aarch64: 176, riscv64: 176],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 275 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(getgid() / {} -> gid_t ~ [Creds, Pure] for [x86_64: 104, aarch64: 176, riscv64: 176)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:282:3
[INFO] [stdout]     |
[INFO] [stdout] 282 |   getitimer(which: c_int, value: *mut itimerval) / { which: c_int } -> c_int + { value: itimerval } ~ [] for [x86_64: 36, aarch64: 102, riscv64: 102],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 282 |   <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)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                                  +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:287:3
[INFO] [stdout]     |
[INFO] [stdout] 287 |   getpgid(pid: pid_t) / { pid: pid_t } -> pid_t ~ [] for [x86_64: 121, aarch64: 155, riscv64: 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] 287 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(getpgid(pid: pid_t) / { pid: pid_t } -> pid_t ~ [] for [x86_64: 121, aarch64: 155, riscv64: 155)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                               +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:291:3
[INFO] [stdout]     |
[INFO] [stdout] 291 |   getpriority(which: c_int, who: id_t) / { which: c_int, who: id_t } -> c_int ~ [] for [x86_64: 140, aarch64: 141, riscv64: 141],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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(getpriority(which: c_int, who: id_t) / { which: c_int, who: id_t } -> c_int ~ [] for [x86_64: 140, aarch64: 141, riscv64: 141)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                             +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:292:3
[INFO] [stdout]     |
[INFO] [stdout] 292 | /   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] 293 | |     ~ [] for [x86_64: 318, aarch64: 278, riscv64: 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] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 292 ~   <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] 293 ~     ~ [] for [x86_64: 318, aarch64: 278, riscv64: 278)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:302:3
[INFO] [stdout]     |
[INFO] [stdout] 302 |   getrlimit(resource: c_int, rlim: *mut rlimit) / { resource: c_int } -> c_int + { rlim: rlimit } ~ [] for [x86_64: 97, aarch64: 163, riscv64: 163],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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(getrlimit(resource: c_int, rlim: *mut rlimit) / { resource: c_int } -> c_int + { rlim: rlimit } ~ [] for [x86_64: 97, aarch64: 163, riscv64: 163)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                                +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:303:3
[INFO] [stdout]     |
[INFO] [stdout] 303 |   getrusage(who: c_int, usage: *mut rusage) / { who: c_int } -> c_int + { usage: rusage } ~ [] for [x86_64: 98, aarch64: 165, riscv64: 165],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 303 |   <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)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:304:3
[INFO] [stdout]     |
[INFO] [stdout] 304 |   getsid(pid: pid_t) / { pid: pid_t } -> pid_t ~ [] for [x86_64: 124, aarch64: 156, riscv64: 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] 304 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(getsid(pid: pid_t) / { pid: pid_t } -> pid_t ~ [] for [x86_64: 124, aarch64: 156, riscv64: 156)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                              +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:314:3
[INFO] [stdout]     |
[INFO] [stdout] 314 |   getuid() / {} -> uid_t ~ [Creds, Pure] for [x86_64: 102, aarch64: 174, riscv64: 174],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 314 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(getuid() / {} -> uid_t ~ [Creds, Pure] for [x86_64: 102, aarch64: 174, riscv64: 174)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:319:3
[INFO] [stdout]     |
[INFO] [stdout] 319 | /   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] 320 | |     { 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],
[INFO] [stdout]     | |__________________________________________________________________________________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 319 ~   <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] 320 ~     { 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)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:324:3
[INFO] [stdout]     |
[INFO] [stdout] 324 | /   init_module(module_image: *mut c_void, len: c_ulong, param_values: *const c_char) /
[INFO] [stdout] 325 | |     { module_image: Vec<u8> @ counted_by(raw_args.len), param_values: CString } -> c_int ~ [] for [x86_64: 175, aarch64: 105, riscv64: 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] 324 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(init_module(module_image: *mut c_void, len: c_ulong, param_values: *const c_char) /
[INFO] [stdout] 325 ~     { module_image: Vec<u8> @ counted_by(raw_args.len), param_values: CString } -> c_int ~ [] for [x86_64: 175, aarch64: 105, riscv64: 105)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:326:3
[INFO] [stdout]     |
[INFO] [stdout] 326 | /   inotify_add_watch(fd: RawFd, pathname: *const c_char, mask: u32) /
[INFO] [stdout] 327 | |     { fd: RawFd, pathname: PathBuf, mask: u32 } -> c_int ~ [Desc, File] for [x86_64: 254, aarch64: 27, riscv64: 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] 326 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(inotify_add_watch(fd: RawFd, pathname: *const c_char, mask: u32) /
[INFO] [stdout] 327 ~     { fd: RawFd, pathname: PathBuf, mask: u32 } -> c_int ~ [Desc, File] for [x86_64: 254, aarch64: 27, riscv64: 27)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:331:3
[INFO] [stdout]     |
[INFO] [stdout] 331 | /   io_cancel(ctx_id: aio_context_t, iocb: *mut iocb, result: *mut io_event) /
[INFO] [stdout] 332 | |     { ctx_id: aio_context_t, iocb: iocb } -> c_int + { result: io_event } ~ [] for [x86_64: 210, aarch64: 3, riscv64: 3],
[INFO] [stdout]     | |_______________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 331 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(io_cancel(ctx_id: aio_context_t, iocb: *mut iocb, result: *mut io_event) /
[INFO] [stdout] 332 ~     { ctx_id: aio_context_t, iocb: iocb } -> c_int + { result: io_event } ~ [] for [x86_64: 210, aarch64: 3, riscv64: 3)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:334:3
[INFO] [stdout]     |
[INFO] [stdout] 334 |   io_destroy(ctx_id: aio_context_t) / { ctx_id: aio_context_t } -> c_int ~ [] for [x86_64: 207, aarch64: 1, riscv64: 1],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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(io_destroy(ctx_id: aio_context_t) / { ctx_id: aio_context_t } -> c_int ~ [] for [x86_64: 207, aarch64: 1, riscv64: 1)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:336:3
[INFO] [stdout]     |
[INFO] [stdout] 336 | /   io_getevents(ctx_id: aio_context_t, min_nr: c_long, nr: c_long, events: *mut io_event, timeout: *mut timespec) /
[INFO] [stdout] 337 | |     { ctx_id: aio_context_t, min_nr: c_long, nr: c_long, timeout: Option<timespec> }
[INFO] [stdout] 338 | |     -> c_int + { events: Vec<io_event> @ counted_by(syscall_result) } ~ [] for [x86_64: 208, aarch64: 4, riscv64: 4],
[INFO] [stdout]     | |___________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 336 ~   <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] 337 |     { ctx_id: aio_context_t, min_nr: c_long, nr: c_long, timeout: Option<timespec> }
[INFO] [stdout] 338 ~     -> c_int + { events: Vec<io_event> @ counted_by(syscall_result) } ~ [] for [x86_64: 208, aarch64: 4, riscv64: 4)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:339:3
[INFO] [stdout]     |
[INFO] [stdout] 339 | /   io_pgetevents(ctx_id: aio_context_t, min_nr: c_long, nr: c_long, events: *mut io_event, timeout: *mut timespec, sig: *const __a...
[INFO] [stdout] 340 | |     { ctx_id: aio_context_t, min_nr: c_long, nr: c_long, timeout: Option<timespec>, sig: __aio_sigset }
[INFO] [stdout] 341 | |     -> c_int + { events: Vec<io_event> @ counted_by(syscall_result) } ~ [] for [x86_64: 333, aarch64: 292, riscv64: 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] 339 ~   <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] 340 |     { ctx_id: aio_context_t, min_nr: c_long, nr: c_long, timeout: Option<timespec>, sig: __aio_sigset }
[INFO] [stdout] 341 ~     -> c_int + { events: Vec<io_event> @ counted_by(syscall_result) } ~ [] for [x86_64: 333, aarch64: 292, riscv64: 292)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:346:3
[INFO] [stdout]     |
[INFO] [stdout] 346 | /   io_submit(ctx: aio_context_t, nr: c_long, iocbs: *mut *mut iocb) /
[INFO] [stdout] 347 | |     { ctx: aio_context_t, iocbs: Vec<AddressType> @ counted_by(raw_args.nr) } -> c_int ~ [] for [x86_64: 209, aarch64: 2, riscv64: 2],
[INFO] [stdout]     | |____________________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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(io_submit(ctx: aio_context_t, nr: c_long, iocbs: *mut *mut iocb) /
[INFO] [stdout] 347 ~     { ctx: aio_context_t, iocbs: Vec<AddressType> @ counted_by(raw_args.nr) } -> c_int ~ [] for [x86_64: 209, aarch64: 2, riscv64: 2)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:349:3
[INFO] [stdout]     |
[INFO] [stdout] 349 | /   io_uring_enter(fd: c_uint, to_submit: c_uint, min_complete: c_uint, flags: c_uint, arg: AddressType, argsz: size_t) /
[INFO] [stdout] 350 | |     { fd: c_uint, to_submit: c_uint, min_complete: c_uint, flags: c_uint, arg: Vec<u8> @ counted_by(raw_args.argsz) }
[INFO] [stdout] 351 | |     -> c_int ~ [Desc, File] for [x86_64: 426, aarch64: 426, riscv64: 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] 349 ~   <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] 350 |     { fd: c_uint, to_submit: c_uint, min_complete: c_uint, flags: c_uint, arg: Vec<u8> @ counted_by(raw_args.argsz) }
[INFO] [stdout] 351 ~     -> c_int ~ [Desc, File] for [x86_64: 426, aarch64: 426, riscv64: 426)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:353:3
[INFO] [stdout]     |
[INFO] [stdout] 353 | /   io_uring_register(fd: c_uint, op: c_uint, arg: AddressType, nr_args: c_uint) /
[INFO] [stdout] 354 | |     { fd: c_uint, op: c_uint, arg: AddressType, nr_args: c_uint } -> c_int ~ [Desc, Memory] for [x86_64: 427, aarch64: 427, riscv64: 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] 353 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(io_uring_register(fd: c_uint, op: c_uint, arg: AddressType, nr_args: c_uint) /
[INFO] [stdout] 354 ~     { fd: c_uint, op: c_uint, arg: AddressType, nr_args: c_uint } -> c_int ~ [Desc, Memory] for [x86_64: 427, aarch64: 427, riscv64: 427)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:359:3
[INFO] [stdout]     |
[INFO] [stdout] 359 |   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] 359 |   <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>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:360:3
[INFO] [stdout]     |
[INFO] [stdout] 360 |   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] 360 |   <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>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:361:3
[INFO] [stdout]     |
[INFO] [stdout] 361 |   ioprio_get(which: c_int, who: c_int) / { which: c_int, who: c_int } -> c_int ~ [] for [x86_64: 252, aarch64: 31, riscv64: 31],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 361 |   <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)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:362:3
[INFO] [stdout]     |
[INFO] [stdout] 362 |   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],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 362 |   <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)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                                          +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:364:3
[INFO] [stdout]     |
[INFO] [stdout] 364 | /   kcmp(pid1: pid_t, pid2: pid_t, r#type: c_int, idx1: c_ulong, idx2: c_ulong) /
[INFO] [stdout] 365 | |     { 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],
[INFO] [stdout]     | |________________________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 364 ~   <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] 365 ~     { 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)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:370:3
[INFO] [stdout]     |
[INFO] [stdout] 370 | /   kexec_load(entry: c_ulong, nr_segments: c_ulong, segments: *mut kexec_segment, flags: c_ulong) /
[INFO] [stdout] 371 | |     { entry: c_ulong, segments: Vec<kexec_segment> @ counted_by(raw_args.nr_segments), flags: c_ulong } -> c_long
[INFO] [stdout] 372 | |     ~ [] for [x86_64: 246, aarch64: 104, riscv64: 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] 370 ~   <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] 371 |     { entry: c_ulong, segments: Vec<kexec_segment> @ counted_by(raw_args.nr_segments), flags: c_ulong } -> c_long
[INFO] [stdout] 372 ~     ~ [] for [x86_64: 246, aarch64: 104, riscv64: 104)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:373:3
[INFO] [stdout]     |
[INFO] [stdout] 373 | /   keyctl(option: c_int, arg2: c_ulong, arg3: c_ulong, arg4: c_ulong, arg5: c_ulong) /
[INFO] [stdout] 374 | |     { 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],
[INFO] [stdout]     | |_____________________________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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(keyctl(option: c_int, arg2: c_ulong, arg3: c_ulong, arg4: c_ulong, arg5: c_ulong) /
[INFO] [stdout] 374 ~     { 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)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:375:3
[INFO] [stdout]     |
[INFO] [stdout] 375 |   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],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 375 |   <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)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                  +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:387:3
[INFO] [stdout]     |
[INFO] [stdout] 387 | /   linkat(olddirfd: RawFd, oldpath: *const c_char, newdirfd: RawFd, newpath: *const c_char, flags: c_int) /
[INFO] [stdout] 388 | |     { olddirfd: RawFd, oldpath: PathBuf, newdirfd: RawFd, newpath: PathBuf, flags: c_int } -> c_int
[INFO] [stdout] 389 | |     ~ [Desc, File] for [x86_64: 265, aarch64: 37, riscv64: 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] 387 ~   <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] 388 |     { olddirfd: RawFd, oldpath: PathBuf, newdirfd: RawFd, newpath: PathBuf, flags: c_int } -> c_int
[INFO] [stdout] 389 ~     ~ [Desc, File] for [x86_64: 265, aarch64: 37, riscv64: 37)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:392:3
[INFO] [stdout]     |
[INFO] [stdout] 392 | /   listmount(req: *const __mount_arg, buf: *mut u64, bufsize: size_t, flags: c_uint) /
[INFO] [stdout] 393 | |     { req: __mount_arg, bufsize: size_t, flags: c_uint } -> c_int + { buf: Vec<u64> @ counted_by(raw_args.bufsize) }
[INFO] [stdout] 394 | |      ~ [] for [x86_64: 458, aarch64: 458, riscv64: 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] 392 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(listmount(req: *const __mount_arg, buf: *mut u64, bufsize: size_t, flags: c_uint) /
[INFO] [stdout] 393 |     { req: __mount_arg, bufsize: size_t, flags: c_uint } -> c_int + { buf: Vec<u64> @ counted_by(raw_args.bufsize) }
[INFO] [stdout] 394 ~      ~ [] for [x86_64: 458, aarch64: 458, riscv64: 458)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:399:3
[INFO] [stdout]     |
[INFO] [stdout] 399 | /   listxattrat(dfd: RawFd, pathname: *const c_char, at_flags: c_uint, list: *mut c_char, size: size_t) /
[INFO] [stdout] 400 | |     { dfd: RawFd, pathname: PathBuf, at_flags: c_uint, size: size_t } -> ssize_t + { list: Option<Vec<CString>> }
[INFO] [stdout] 401 | |     ~ [File, Desc] for [x86_64: 465, aarch64: 465, riscv64: 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] 399 ~   <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] 400 |     { dfd: RawFd, pathname: PathBuf, at_flags: c_uint, size: size_t } -> ssize_t + { list: Option<Vec<CString>> }
[INFO] [stdout] 401 ~     ~ [File, Desc] for [x86_64: 465, aarch64: 465, riscv64: 465)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:402:3
[INFO] [stdout]     |
[INFO] [stdout] 402 | /   lookup_dcookie(cookie: u64, buffer: *mut c_char, len: size_t) /
[INFO] [stdout] 403 | |     { cookie: u64, len: size_t } -> c_long + { buffer: PathBuf } ~ [] for [x86_64: 212, aarch64: 18, riscv64: 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] 402 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(lookup_dcookie(cookie: u64, buffer: *mut c_char, len: size_t) /
[INFO] [stdout] 403 ~     { cookie: u64, len: size_t } -> c_long + { buffer: PathBuf } ~ [] for [x86_64: 212, aarch64: 18, riscv64: 18)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:410:3
[INFO] [stdout]     |
[INFO] [stdout] 410 | /   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] 411 | |     -> c_int + { ctx: Vec<u8> } ~ [] for [x86_64: 459, aarch64: 459, riscv64: 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] 410 ~   <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] 411 ~     -> c_int + { ctx: Vec<u8> } ~ [] for [x86_64: 459, aarch64: 459, riscv64: 459)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:412:3
[INFO] [stdout]     |
[INFO] [stdout] 412 | /   lsm_list_modules(ids: *mut u64, size: *mut u32, flags: u32) / { size: InspectResult<u32>, flags: u32 }
[INFO] [stdout] 413 | |     -> c_int + { size: InspectResult<u32>, ids: Vec<u64> @ counted_by_result(size) } ~ [] for [x86_64: 461, aarch64: 461, riscv64: 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] 412 ~   <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] 413 ~     -> c_int + { size: InspectResult<u32>, ids: Vec<u64> @ counted_by_result(size) } ~ [] for [x86_64: 461, aarch64: 461, riscv64: 461)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:414:3
[INFO] [stdout]     |
[INFO] [stdout] 414 | /   lsm_set_self_attr(attr: c_uint, ctx: *const c_void, size: u32, flags: u32) /
[INFO] [stdout] 415 | |     { attr: c_uint, ctx: Vec<u8> @ counted_by(raw_args.size), flags: u32 } -> c_int ~ [] for [x86_64: 460, aarch64: 460, riscv64: 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] 414 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(lsm_set_self_attr(attr: c_uint, ctx: *const c_void, size: u32, flags: u32) /
[INFO] [stdout] 415 ~     { attr: c_uint, ctx: Vec<u8> @ counted_by(raw_args.size), flags: u32 } -> c_int ~ [] for [x86_64: 460, aarch64: 460, riscv64: 460)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:416:3
[INFO] [stdout]     |
[INFO] [stdout] 416 |   lstat(pathname: *const c_char, statbuf: *mut stat) / { pathname: PathBuf } -> c_int + { statbuf: stat } ~ [File, LStat, StatLike] for [x86_64: 6],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 416 |   <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)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                                +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:442:3
[INFO] [stdout]     |
[INFO] [stdout] 442 | /   mkdirat(dirfd: RawFd, pathname: *const c_char, mode: mode_t) / { dirfd: RawFd, pathname: PathBuf, mode: mode_t } -> c_int
[INFO] [stdout] 443 | |     ~ [Desc, File] for [x86_64: 258, aarch64: 34, riscv64: 34],
[INFO] [stdout]     | |_____________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 442 ~   <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] 443 ~     ~ [Desc, File] for [x86_64: 258, aarch64: 34, riscv64: 34)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:445:3
[INFO] [stdout]     |
[INFO] [stdout] 445 | /   mknodat(dirfd: RawFd, pathname: *const c_char, mode: mode_t, dev: dev_t) /
[INFO] [stdout] 446 | |     { dirfd: RawFd, pathname: PathBuf, mode: mode_t, dev: dev_t } -> c_int ~ [Desc, File] for [x86_64: 259, aarch64: 33, riscv64: 33],
[INFO] [stdout]     | |____________________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 445 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(mknodat(dirfd: RawFd, pathname: *const c_char, mode: mode_t, dev: dev_t) /
[INFO] [stdout] 446 ~     { dirfd: RawFd, pathname: PathBuf, mode: mode_t, dev: dev_t } -> c_int ~ [Desc, File] for [x86_64: 259, aarch64: 33, riscv64: 33)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:455:3
[INFO] [stdout]     |
[INFO] [stdout] 455 | /   modify_ldt(func: c_int, ptr: *mut c_void, bytecount: c_ulong) / { func: c_int, ptr: AddressType, bytecount: c_ulong } -> c_int
[INFO] [stdout] 456 | |     ~ [] 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] 455 ~   <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] 456 ~     ~ [] for [x86_64: 154)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:460:3
[INFO] [stdout]     |
[INFO] [stdout] 460 | /   mount_setattr(dirfd: RawFd, pathname: *const c_char, flags: c_uint, uattr: *mut c_void, r#usize: size_t) /
[INFO] [stdout] 461 | |     { dirfd: RawFd, pathname: PathBuf, flags: c_uint, uattr: Arc<mount_attr> @ sized_by(raw_args.r#usize) } -> c_int
[INFO] [stdout] 462 | |     ~ [Desc, File] for [x86_64: 442, aarch64: 442, riscv64: 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] 460 ~   <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] 461 |     { dirfd: RawFd, pathname: PathBuf, flags: c_uint, uattr: Arc<mount_attr> @ sized_by(raw_args.r#usize) } -> c_int
[INFO] [stdout] 462 ~     ~ [Desc, File] for [x86_64: 442, aarch64: 442, riscv64: 442)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:463:3
[INFO] [stdout]     |
[INFO] [stdout] 463 | /   move_mount(from_dfd: RawFd, from_path: *const c_char, to_dfd: RawFd, to_path: *const c_char, ms_flags: c_uint) /
[INFO] [stdout] 464 | |     { from_dfd: RawFd, from_path: PathBuf, to_dfd: RawFd, to_path: PathBuf, ms_flags: c_uint } -> c_int
[INFO] [stdout] 465 | |     ~ [Desc, File] for [x86_64: 429, aarch64: 429, riscv64: 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] 463 ~   <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] 464 |     { from_dfd: RawFd, from_path: PathBuf, to_dfd: RawFd, to_path: PathBuf, ms_flags: c_uint } -> c_int
[INFO] [stdout] 465 ~     ~ [Desc, File] for [x86_64: 429, aarch64: 429, riscv64: 429)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:491:3
[INFO] [stdout]     |
[INFO] [stdout] 491 |   mq_unlink(name: *const c_char) / { name: CString } -> c_int ~ [] for [x86_64: 241, aarch64: 181, riscv64: 181],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 491 |   <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)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                             +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:498:3
[INFO] [stdout]     |
[INFO] [stdout] 498 | /   msgctl(msqid: c_int, cmd: c_int, buf: *mut msqid_ds) / { msqid: c_int, cmd: c_int } -> c_int + { buf: msqid_ds }
[INFO] [stdout] 499 | |     ~ [] for [x86_64: 71, aarch64: 187, riscv64: 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] 498 ~   <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] 499 ~     ~ [] for [x86_64: 71, aarch64: 187, riscv64: 187)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:500:3
[INFO] [stdout]     |
[INFO] [stdout] 500 |   msgget(key: key_t, msgflg: c_int) / { key: key_t, msgflg: c_int } -> c_int ~ [] for [x86_64: 68, aarch64: 186, riscv64: 186],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 500 |   <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)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:501:3
[INFO] [stdout]     |
[INFO] [stdout] 501 | /   msgrcv(msqid: c_int, msgp: *mut c_void, msgsz: size_t, msgtyp: c_long, msgflg: c_int) /
[INFO] [stdout] 502 | |     { 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] 503 | |     ~ [] for [x86_64: 70, aarch64: 188, riscv64: 188],
[INFO] [stdout]     | |____________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 501 ~   <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] 502 |     { 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] 503 ~     ~ [] for [x86_64: 70, aarch64: 188, riscv64: 188)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:504:3
[INFO] [stdout]     |
[INFO] [stdout] 504 | /   msgsnd(msqid: c_int, msgp: *const c_void, msgsz: size_t, msgflg: c_int) /
[INFO] [stdout] 505 | |     { 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],
[INFO] [stdout]     | |__________________________________________________________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 504 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(msgsnd(msqid: c_int, msgp: *const c_void, msgsz: size_t, msgflg: c_int) /
[INFO] [stdout] 505 ~     { 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)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:512:3
[INFO] [stdout]     |
[INFO] [stdout] 512 | /   name_to_handle_at(dirfd: RawFd, pathname: *const c_char, handle: *mut c_void, mount_id: *mut c_int, flags: c_int) /
[INFO] [stdout] 513 | |     { dirfd: RawFd, pathname: PathBuf, flags: c_int } -> c_int +
[INFO] [stdout] 514 | |     { handle: Arc<file_handle> @ sized_by_result(<InspectResult<c_uint> as InspectFromPid>::inspect_from(inspectee_pid, raw_args....
[INFO] [stdout] 515 | |       mount_id: InspectResult<c_int> }
[INFO] [stdout] 516 | |     ~ [Desc, File] for [x86_64: 303, aarch64: 264, riscv64: 264],
[INFO] [stdout]     | |_______________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 512 ~   <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] 513 |     { dirfd: RawFd, pathname: PathBuf, flags: c_int } -> c_int +
[INFO] [stdout] 514 |     { handle: Arc<file_handle> @ sized_by_result(<InspectResult<c_uint> as InspectFromPid>::inspect_from(inspectee_pid, raw_args.handle as AddressType)),
[INFO] [stdout] 515 |       mount_id: InspectResult<c_int> }
[INFO] [stdout] 516 ~     ~ [Desc, File] for [x86_64: 303, aarch64: 264, riscv64: 264)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:519:3
[INFO] [stdout]     |
[INFO] [stdout] 519 | /   newfstatat(dirfd: RawFd, pathname: *const c_char, statbuf: *mut stat, flags: c_int) /
[INFO] [stdout] 520 | |     { dirfd: RawFd, pathname: PathBuf, flags: c_int } -> c_int + { statbuf: stat }
[INFO] [stdout] 521 | |     ~ [Desc, File, FStat, StatLike] for [x86_64: 262, aarch64: 79, riscv64: 79],
[INFO] [stdout]     | |______________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 519 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(newfstatat(dirfd: RawFd, pathname: *const c_char, statbuf: *mut stat, flags: c_int) /
[INFO] [stdout] 520 |     { dirfd: RawFd, pathname: PathBuf, flags: c_int } -> c_int + { statbuf: stat }
[INFO] [stdout] 521 ~     ~ [Desc, File, FStat, StatLike] for [x86_64: 262, aarch64: 79, riscv64: 79)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:530:3
[INFO] [stdout]     |
[INFO] [stdout] 530 | /   open(pathname: *const c_char, flags: c_int, mode: mode_t) / { pathname: PathBuf, flags: c_int, mode: mode_t } -> RawFd
[INFO] [stdout] 531 | |     ~ [Desc, File] for [x86_64: 2, aarch64: 56, riscv64: 56],
[INFO] [stdout]     | |___________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 530 ~   <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] 531 ~     ~ [Desc, File] for [x86_64: 2, aarch64: 56, riscv64: 56)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:537:3
[INFO] [stdout]     |
[INFO] [stdout] 537 | /   open_tree(dirfd: RawFd, path: *const c_char, flags: c_uint) / { dirfd: RawFd, path: PathBuf, flags: c_uint } -> c_int
[INFO] [stdout] 538 | |     ~ [Desc, File] for [x86_64: 428, aarch64: 428, riscv64: 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] 537 ~   <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] 538 ~     ~ [Desc, File] for [x86_64: 428, aarch64: 428, riscv64: 428)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:539:3
[INFO] [stdout]     |
[INFO] [stdout] 539 | /   open_tree_attr(dfd: RawFd, filename: *const c_char, flags: c_uint, uattr: *mut c_void, r#usize: size_t) /
[INFO] [stdout] 540 | |     { dfd: RawFd, filename: PathBuf, flags: c_uint, uattr: Arc<mount_attr> @ sized_by(raw_args.r#usize) } -> c_int
[INFO] [stdout] 541 | |     ~ [Desc, File] for [x86_64: 467, aarch64: 467, riscv64: 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] 539 ~   <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] 540 |     { dfd: RawFd, filename: PathBuf, flags: c_uint, uattr: Arc<mount_attr> @ sized_by(raw_args.r#usize) } -> c_int
[INFO] [stdout] 541 ~     ~ [Desc, File] for [x86_64: 467, aarch64: 467, riscv64: 467)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:542:3
[INFO] [stdout]     |
[INFO] [stdout] 542 | /   openat(dirfd: RawFd, pathname: *const c_char, flags: c_int, mode: mode_t) /
[INFO] [stdout] 543 | |     { dirfd: RawFd, pathname: PathBuf, flags: c_int, mode: mode_t } -> RawFd ~ [Desc, File] for [x86_64: 257, aarch64: 56, riscv64: 56],
[INFO] [stdout]     | |______________________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 542 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(openat(dirfd: RawFd, pathname: *const c_char, flags: c_int, mode: mode_t) /
[INFO] [stdout] 543 ~     { dirfd: RawFd, pathname: PathBuf, flags: c_int, mode: mode_t } -> RawFd ~ [Desc, File] for [x86_64: 257, aarch64: 56, riscv64: 56)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:544:3
[INFO] [stdout]     |
[INFO] [stdout] 544 | /   openat2(dirfd: RawFd, pathname: *const c_char, how: *mut open_how, size: size_t) /
[INFO] [stdout] 545 | |     { dirfd: RawFd, pathname: PathBuf, how: open_how, size: size_t } -> c_int ~ [Desc, File] for [x86_64: 437, aarch64: 437, riscv64: 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] 544 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(openat2(dirfd: RawFd, pathname: *const c_char, how: *mut open_how, size: size_t) /
[INFO] [stdout] 545 ~     { dirfd: RawFd, pathname: PathBuf, how: open_how, size: size_t } -> c_int ~ [Desc, File] for [x86_64: 437, aarch64: 437, riscv64: 437)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:557:3
[INFO] [stdout]     |
[INFO] [stdout] 557 |   personality(persona: c_ulong) / { persona: c_ulong } -> c_int ~ [] for [x86_64: 135, aarch64: 92, riscv64: 92],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 557 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(personality(persona: c_ulong) / { persona: c_ulong } -> c_int ~ [] for [x86_64: 135, aarch64: 92, riscv64: 92)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                             +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:561:3
[INFO] [stdout]     |
[INFO] [stdout] 561 | /   pidfd_send_signal(pidfd: RawFd, sig: c_int, info: *mut siginfo_t, flags: c_uint) /
[INFO] [stdout] 562 | |     { pidfd: RawFd, sig: c_int, info: Option<siginfo_t>, flags: c_uint } -> c_int
[INFO] [stdout] 563 | |     ~ [Desc, Signal, Process] for [x86_64: 424, aarch64: 424, riscv64: 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] 561 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(pidfd_send_signal(pidfd: RawFd, sig: c_int, info: *mut siginfo_t, flags: c_uint) /
[INFO] [stdout] 562 |     { pidfd: RawFd, sig: c_int, info: Option<siginfo_t>, flags: c_uint } -> c_int
[INFO] [stdout] 563 ~     ~ [Desc, Signal, Process] for [x86_64: 424, aarch64: 424, riscv64: 424)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:568:3
[INFO] [stdout]     |
[INFO] [stdout] 568 |   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],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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(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)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                                      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:569:3
[INFO] [stdout]     |
[INFO] [stdout] 569 |   pkey_free(pkey: c_int) / { pkey: c_int } -> c_int ~ [] for [x86_64: 331, aarch64: 290, riscv64: 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] 569 |   <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)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:589:3
[INFO] [stdout]     |
[INFO] [stdout] 589 | /   prlimit64(pid: pid_t, resource: c_int, new_limit: *const rlimit64, old_limit: *mut rlimit64) /
[INFO] [stdout] 590 | |     { pid: pid_t, resource: c_int, new_limit: Option<rlimit64>, old_limit: Option<rlimit64> } -> c_int + { old_limit: Option<rlim...
[INFO] [stdout] 591 | |     ~ [] for [x86_64: 302, aarch64: 261, riscv64: 261],
[INFO] [stdout]     | |_____________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 589 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(prlimit64(pid: pid_t, resource: c_int, new_limit: *const rlimit64, old_limit: *mut rlimit64) /
[INFO] [stdout] 590 |     { pid: pid_t, resource: c_int, new_limit: Option<rlimit64>, old_limit: Option<rlimit64> } -> c_int + { old_limit: Option<rlimit64> }
[INFO] [stdout] 591 ~     ~ [] for [x86_64: 302, aarch64: 261, riscv64: 261)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:596:3
[INFO] [stdout]     |
[INFO] [stdout] 596 | /   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] 597 | |     { pid: pid_t, local_iov: Vec<iovec> @ counted_by(raw_args.liovcnt), remote_iov: Vec<iovec> @ counted_by(raw_args.riovcnt), fl...
[INFO] [stdout] 598 | |     -> ssize_t ~ [] for [x86_64: 310, aarch64: 270, riscv64: 270],
[INFO] [stdout]     | |________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 596 ~   <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] 597 |     { 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] 598 ~     -> ssize_t ~ [] for [x86_64: 310, aarch64: 270, riscv64: 270)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:599:3
[INFO] [stdout]     |
[INFO] [stdout] 599 | /   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] 600 | |     { pid: pid_t, local_iov: Vec<iovec> @ counted_by(raw_args.liovcnt), remote_iov: Vec<iovec> @ counted_by(raw_args.riovcnt), fl...
[INFO] [stdout] 601 | |     -> ssize_t ~ [] for [x86_64: 311, aarch64: 271, riscv64: 271],
[INFO] [stdout]     | |________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 599 ~   <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] 600 |     { 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] 601 ~     -> ssize_t ~ [] for [x86_64: 311, aarch64: 271, riscv64: 271)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:608:3
[INFO] [stdout]     |
[INFO] [stdout] 608 | /   ptrace(request: c_int, pid: pid_t, addr: *mut c_void, data: *mut c_void) / { } -> c_long
[INFO] [stdout] 609 | |     ~ [] for [x86_64: 101, aarch64: 117, riscv64: 117],
[INFO] [stdout]     | |_____________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 608 ~   <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] 609 ~     ~ [] for [x86_64: 101, aarch64: 117, riscv64: 117)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:627:3
[INFO] [stdout]     |
[INFO] [stdout] 627 | /   readlinkat(dirfd: RawFd, pathname: *const c_char, buf: *mut c_char, bufsiz: size_t) /
[INFO] [stdout] 628 | |     { dirfd: RawFd, pathname: PathBuf, bufsiz: size_t } -> ssize_t + { buf: Vec<u8> @ counted_by(syscall_result) }
[INFO] [stdout] 629 | |     ~ [Desc, File] for [x86_64: 267, aarch64: 78, riscv64: 78],
[INFO] [stdout]     | |_____________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 627 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(readlinkat(dirfd: RawFd, pathname: *const c_char, buf: *mut c_char, bufsiz: size_t) /
[INFO] [stdout] 628 |     { dirfd: RawFd, pathname: PathBuf, bufsiz: size_t } -> ssize_t + { buf: Vec<u8> @ counted_by(syscall_result) }
[INFO] [stdout] 629 ~     ~ [Desc, File] for [x86_64: 267, aarch64: 78, riscv64: 78)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:632:3
[INFO] [stdout]     |
[INFO] [stdout] 632 | /   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] 633 | |     ~ [] for [x86_64: 169, aarch64: 142, riscv64: 142],
[INFO] [stdout]     | |_____________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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(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] 633 ~     ~ [] for [x86_64: 169, aarch64: 142, riscv64: 142)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:649:3
[INFO] [stdout]     |
[INFO] [stdout] 649 | /   removexattrat(dfd: RawFd, pathname: *const c_char, at_flags: c_uint, name: *const c_char) /
[INFO] [stdout] 650 | |     { dfd: RawFd, pathname: PathBuf, at_flags: c_uint, name: CString } -> c_int
[INFO] [stdout] 651 | |     ~ [File, Desc] for [x86_64: 466, aarch64: 466, riscv64: 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] 649 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(removexattrat(dfd: RawFd, pathname: *const c_char, at_flags: c_uint, name: *const c_char) /
[INFO] [stdout] 650 |     { dfd: RawFd, pathname: PathBuf, at_flags: c_uint, name: CString } -> c_int
[INFO] [stdout] 651 ~     ~ [File, Desc] for [x86_64: 466, aarch64: 466, riscv64: 466)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:654:3
[INFO] [stdout]     |
[INFO] [stdout] 654 | /   renameat(olddirfd: RawFd, oldpath: *const c_char, newdirfd: RawFd, newpath: *const c_char) /
[INFO] [stdout] 655 | |     { olddirfd: RawFd, oldpath: PathBuf, newdirfd: RawFd, newpath: PathBuf } -> c_int
[INFO] [stdout] 656 | |     ~ [Desc, File] for [x86_64: 264, aarch64: 38],
[INFO] [stdout]     | |________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 654 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(renameat(olddirfd: RawFd, oldpath: *const c_char, newdirfd: RawFd, newpath: *const c_char) /
[INFO] [stdout] 655 |     { olddirfd: RawFd, oldpath: PathBuf, newdirfd: RawFd, newpath: PathBuf } -> c_int
[INFO] [stdout] 656 ~     ~ [Desc, File] for [x86_64: 264, aarch64: 38)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:657:3
[INFO] [stdout]     |
[INFO] [stdout] 657 | /   renameat2(olddirfd: RawFd, oldpath: *const c_char, newdirfd: RawFd, newpath: *const c_char, flags: c_uint) /
[INFO] [stdout] 658 | |     { olddirfd: RawFd, oldpath: PathBuf, newdirfd: RawFd, newpath: PathBuf, flags: c_uint } -> c_int
[INFO] [stdout] 659 | |     ~ [Desc, File] for [x86_64: 316, aarch64: 276, riscv64: 276],
[INFO] [stdout]     | |_______________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 657 ~   <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] 658 |     { olddirfd: RawFd, oldpath: PathBuf, newdirfd: RawFd, newpath: PathBuf, flags: c_uint } -> c_int
[INFO] [stdout] 659 ~     ~ [Desc, File] for [x86_64: 316, aarch64: 276, riscv64: 276)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:660:3
[INFO] [stdout]     |
[INFO] [stdout] 660 | /   request_key(r#type: *const c_char, description: *const c_char, callout_info: *const c_char, dest_keyring: key_serial_t) /
[INFO] [stdout] 661 | |     { r#type: CString, description: CString, callout_info: Option<CString>, dest_keyring: key_serial_t } -> key_serial_t
[INFO] [stdout] 662 | |     ~ [] for [x86_64: 249, aarch64: 218, riscv64: 218],
[INFO] [stdout]     | |_____________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 660 ~   <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] 661 |     { r#type: CString, description: CString, callout_info: Option<CString>, dest_keyring: key_serial_t } -> key_serial_t
[INFO] [stdout] 662 ~     ~ [] for [x86_64: 249, aarch64: 218, riscv64: 218)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:663:3
[INFO] [stdout]     |
[INFO] [stdout] 663 |   restart_syscall() / {} -> c_long ~ [] for [x86_64: 219, aarch64: 128, riscv64: 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] 663 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(restart_syscall() / {} -> c_long ~ [] for [x86_64: 219, aarch64: 128, riscv64: 128)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                  +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:674:3
[INFO] [stdout]     |
[INFO] [stdout] 674 | /   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] 675 | |     ~ [] for [x86_64: 334, aarch64: 293, riscv64: 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] 674 ~   <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] 675 ~     ~ [] for [x86_64: 334, aarch64: 293, riscv64: 293)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:684:3
[INFO] [stdout]     |
[INFO] [stdout] 684 | /   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] 685 | |     ~ [Signal, Process] for [x86_64: 129, aarch64: 138, riscv64: 138],
[INFO] [stdout]     | |____________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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(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] 685 ~     ~ [Signal, Process] for [x86_64: 129, aarch64: 138, riscv64: 138)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:694:3
[INFO] [stdout]     |
[INFO] [stdout] 694 | /   rt_tgsigqueueinfo(tgid: pid_t, pid: pid_t, sig: c_int, info: *mut siginfo_t) /
[INFO] [stdout] 695 | |     { tgid: pid_t, pid: pid_t, sig: c_int, info: siginfo_t } -> c_int ~ [Signal, Process] for [x86_64: 297, aarch64: 240, riscv64: 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] 694 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(rt_tgsigqueueinfo(tgid: pid_t, pid: pid_t, sig: c_int, info: *mut siginfo_t) /
[INFO] [stdout] 695 ~     { tgid: pid_t, pid: pid_t, sig: c_int, info: siginfo_t } -> c_int ~ [Signal, Process] for [x86_64: 297, aarch64: 240, riscv64: 240)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:698:3
[INFO] [stdout]     |
[INFO] [stdout] 698 |   sched_get_priority_max(policy: c_int) / { policy: c_int } -> c_int ~ [] for [x86_64: 146, aarch64: 125, riscv64: 125],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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(sched_get_priority_max(policy: c_int) / { policy: c_int } -> c_int ~ [] for [x86_64: 146, aarch64: 125, riscv64: 125)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:699:3
[INFO] [stdout]     |
[INFO] [stdout] 699 |   sched_get_priority_min(policy: c_int) / { policy: c_int } -> c_int ~ [] for [x86_64: 147, aarch64: 126, riscv64: 126],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 699 |   <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)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:701:3
[INFO] [stdout]     |
[INFO] [stdout] 701 | /   sched_getaffinity(pid: pid_t, cpusetsize: size_t, mask: *mut c_ulong) /
[INFO] [stdout] 702 | |     { pid: pid_t, cpusetsize: size_t } -> c_int + { mask: Vec<u8> @ counted_by(syscall_result) }
[INFO] [stdout] 703 | |     ~ [] for [x86_64: 204, aarch64: 123, riscv64: 123],
[INFO] [stdout]     | |_____________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 701 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(sched_getaffinity(pid: pid_t, cpusetsize: size_t, mask: *mut c_ulong) /
[INFO] [stdout] 702 |     { pid: pid_t, cpusetsize: size_t } -> c_int + { mask: Vec<u8> @ counted_by(syscall_result) }
[INFO] [stdout] 703 ~     ~ [] for [x86_64: 204, aarch64: 123, riscv64: 123)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:704:3
[INFO] [stdout]     |
[INFO] [stdout] 704 | /   sched_getattr(pid: pid_t, attr: *mut sched_attr, size: c_uint, flags: c_uint) /
[INFO] [stdout] 705 | |     { pid: pid_t, size: c_uint, flags: c_uint } -> c_int + { attr: sched_attr }
[INFO] [stdout] 706 | |     ~ [] for [x86_64: 315, aarch64: 275, riscv64: 275],
[INFO] [stdout]     | |_____________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 704 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(sched_getattr(pid: pid_t, attr: *mut sched_attr, size: c_uint, flags: c_uint) /
[INFO] [stdout] 705 |     { pid: pid_t, size: c_uint, flags: c_uint } -> c_int + { attr: sched_attr }
[INFO] [stdout] 706 ~     ~ [] for [x86_64: 315, aarch64: 275, riscv64: 275)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:707:3
[INFO] [stdout]     |
[INFO] [stdout] 707 | /   sched_getparam(pid: pid_t, param: *mut sched_param) / { pid: pid_t } -> c_int + { param: sched_param }
[INFO] [stdout] 708 | |     ~ [] for [x86_64: 143, aarch64: 121, riscv64: 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] 707 ~   <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] 708 ~     ~ [] for [x86_64: 143, aarch64: 121, riscv64: 121)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:709:3
[INFO] [stdout]     |
[INFO] [stdout] 709 |   sched_getscheduler(pid: pid_t) / { pid: pid_t } -> c_int ~ [] for [x86_64: 145, aarch64: 120, riscv64: 120],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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(sched_getscheduler(pid: pid_t) / { pid: pid_t } -> c_int ~ [] for [x86_64: 145, aarch64: 120, riscv64: 120)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                          +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:710:3
[INFO] [stdout]     |
[INFO] [stdout] 710 | /   sched_rr_get_interval(pid: pid_t, tp: *mut timespec) / { pid: pid_t } -> c_int + { tp: timespec }
[INFO] [stdout] 711 | |     ~ [] for [x86_64: 148, aarch64: 127, riscv64: 127],
[INFO] [stdout]     | |_____________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 710 ~   <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] 711 ~     ~ [] for [x86_64: 148, aarch64: 127, riscv64: 127)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:714:3
[INFO] [stdout]     |
[INFO] [stdout] 714 | /   sched_setaffinity(pid: pid_t, cpusetsize: size_t, mask: *const c_ulong) /
[INFO] [stdout] 715 | |     { pid: pid_t, cpusetsize: size_t, mask: Vec<u8> @ counted_by(cpusetsize) } -> c_int
[INFO] [stdout] 716 | |     ~ [] for [x86_64: 203, aarch64: 122, riscv64: 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] 714 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(sched_setaffinity(pid: pid_t, cpusetsize: size_t, mask: *const c_ulong) /
[INFO] [stdout] 715 |     { pid: pid_t, cpusetsize: size_t, mask: Vec<u8> @ counted_by(cpusetsize) } -> c_int
[INFO] [stdout] 716 ~     ~ [] for [x86_64: 203, aarch64: 122, riscv64: 122)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:718:3
[INFO] [stdout]     |
[INFO] [stdout] 718 | /   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] 719 | |     ~ [] for [x86_64: 314, aarch64: 274, riscv64: 274],
[INFO] [stdout]     | |_____________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 718 ~   <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] 719 ~     ~ [] for [x86_64: 314, aarch64: 274, riscv64: 274)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:720:3
[INFO] [stdout]     |
[INFO] [stdout] 720 | /   sched_setparam(pid: pid_t, param: *const sched_param) / { pid: pid_t, param: sched_param } -> c_int
[INFO] [stdout] 721 | |     ~ [] for [x86_64: 142, aarch64: 118, riscv64: 118],
[INFO] [stdout]     | |_____________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 720 ~   <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] 721 ~     ~ [] for [x86_64: 142, aarch64: 118, riscv64: 118)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:722:3
[INFO] [stdout]     |
[INFO] [stdout] 722 | /   sched_setscheduler(pid: pid_t, policy: c_int, param: *const sched_param) /
[INFO] [stdout] 723 | |     { pid: pid_t, policy: c_int, param: sched_param } -> c_int
[INFO] [stdout] 724 | |     ~ [] for [x86_64: 144, aarch64: 119, riscv64: 119],
[INFO] [stdout]     | |_____________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 722 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(sched_setscheduler(pid: pid_t, policy: c_int, param: *const sched_param) /
[INFO] [stdout] 723 |     { pid: pid_t, policy: c_int, param: sched_param } -> c_int
[INFO] [stdout] 724 ~     ~ [] for [x86_64: 144, aarch64: 119, riscv64: 119)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:725:3
[INFO] [stdout]     |
[INFO] [stdout] 725 |   sched_yield() / {} -> c_int ~ [] for [x86_64: 24, aarch64: 124, riscv64: 124],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 725 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(sched_yield() / {} -> c_int ~ [] for [x86_64: 24, aarch64: 124, riscv64: 124)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:727:3
[INFO] [stdout]     |
[INFO] [stdout] 727 | /   seccomp(operation: c_int, flags: c_uint, args: *mut c_void) / { operation: c_int, flags: c_uint } -> c_int
[INFO] [stdout] 728 | |     ~ [] for [x86_64: 317, aarch64: 277, riscv64: 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] 727 ~   <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] 728 ~     ~ [] for [x86_64: 317, aarch64: 277, riscv64: 277)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:745:3
[INFO] [stdout]     |
[INFO] [stdout] 745 | /   sendfile(out_fd: RawFd, in_fd: RawFd, offset: *mut off_t, count: size_t) /
[INFO] [stdout] 746 | |     { out_fd: RawFd, in_fd: RawFd, offset: off_t, count: size_t } -> ssize_t ~ [Desc, Network] for [x86_64: 40, aarch64: 71, riscv64: 71],
[INFO] [stdout]     | |________________________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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(sendfile(out_fd: RawFd, in_fd: RawFd, offset: *mut off_t, count: size_t) /
[INFO] [stdout] 746 ~     { out_fd: RawFd, in_fd: RawFd, offset: off_t, count: size_t } -> ssize_t ~ [Desc, Network] for [x86_64: 40, aarch64: 71, riscv64: 71)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:764:3
[INFO] [stdout]     |
[INFO] [stdout] 764 | /   set_robust_list(head: *mut robust_list_head, len: size_t) / { head: AddressType, len: size_t } -> c_long
[INFO] [stdout] 765 | |     ~ [] for [x86_64: 273, aarch64: 99, riscv64: 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] 764 ~   <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] 765 ~     ~ [] for [x86_64: 273, aarch64: 99, riscv64: 99)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:766:3
[INFO] [stdout]     |
[INFO] [stdout] 766 |   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] 766 |   <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>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:767:3
[INFO] [stdout]     |
[INFO] [stdout] 767 |   set_tid_address(tidptr: *mut c_int) / { tidptr: AddressType } -> pid_t ~ [] for [x86_64: 218, aarch64: 96, riscv64: 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] 767 |   <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)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:769:3
[INFO] [stdout]     |
[INFO] [stdout] 769 |   setdomainname(name: *const c_char, len: size_t) / { name: CString } -> c_int ~ [] for [x86_64: 171, aarch64: 162, riscv64: 162],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 769 |   <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)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                              +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:781:3
[INFO] [stdout]     |
[INFO] [stdout] 781 | /   sethostname(name: *const c_char, len: size_t) / { name: CString, len: size_t } -> c_int
[INFO] [stdout] 782 | |     ~ [] for [x86_64: 170, aarch64: 161, riscv64: 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] 781 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(sethostname(name: *const c_char, len: size_t) / { name: CString, len: size_t } -> c_int
[INFO] [stdout] 782 ~     ~ [] for [x86_64: 170, aarch64: 161, riscv64: 161)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:783:3
[INFO] [stdout]     |
[INFO] [stdout] 783 | /   setitimer(which: c_int, new_value: *const itimerval, old_value: *mut itimerval) /
[INFO] [stdout] 784 | |     { which: c_int, new_value: itimerval, old_value: Option<itimerval> } -> c_int
[INFO] [stdout] 785 | |     ~ [] for [x86_64: 38, aarch64: 103, riscv64: 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] 783 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(setitimer(which: c_int, new_value: *const itimerval, old_value: *mut itimerval) /
[INFO] [stdout] 784 |     { which: c_int, new_value: itimerval, old_value: Option<itimerval> } -> c_int
[INFO] [stdout] 785 ~     ~ [] for [x86_64: 38, aarch64: 103, riscv64: 103)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:787:3
[INFO] [stdout]     |
[INFO] [stdout] 787 |   setpgid(pid: pid_t, pgid: pid_t) / { pid: pid_t, pgid: pid_t } -> c_int ~ [] for [x86_64: 109, aarch64: 154, riscv64: 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] 787 |   <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)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                         +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:789:3
[INFO] [stdout]     |
[INFO] [stdout] 789 | /   setpriority(which: c_int, who: id_t, prio: c_int) / { which: c_int, who: id_t, prio: c_int } -> c_int
[INFO] [stdout] 790 | |     ~ [] for [x86_64: 141, aarch64: 140, riscv64: 140],
[INFO] [stdout]     | |_____________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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(setpriority(which: c_int, who: id_t, prio: c_int) / { which: c_int, who: id_t, prio: c_int } -> c_int
[INFO] [stdout] 790 ~     ~ [] for [x86_64: 141, aarch64: 140, riscv64: 140)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:801:3
[INFO] [stdout]     |
[INFO] [stdout] 801 | /   setrlimit(resource: c_int, rlim: *const rlimit) / { resource: c_int, rlim: rlimit } -> c_int
[INFO] [stdout] 802 | |     ~ [] for [x86_64: 160, aarch64: 164, riscv64: 164],
[INFO] [stdout]     | |_____________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 801 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(setrlimit(resource: c_int, rlim: *const rlimit) / { resource: c_int, rlim: rlimit } -> c_int
[INFO] [stdout] 802 ~     ~ [] for [x86_64: 160, aarch64: 164, riscv64: 164)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:803:3
[INFO] [stdout]     |
[INFO] [stdout] 803 |   setsid() / {} -> pid_t ~ [] for [x86_64: 112, aarch64: 157, riscv64: 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] 803 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(setsid() / {} -> pid_t ~ [] for [x86_64: 112, aarch64: 157, riscv64: 157)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:814:3
[INFO] [stdout]     |
[INFO] [stdout] 814 | /   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] 815 | |     { dfd: RawFd, pathname: PathBuf, at_flags: c_uint, name: CString, uargs: Arc<xattr_args> @ sized_by(raw_args.r#usize) } -> c_int
[INFO] [stdout] 816 | |     ~ [File, Desc] for [x86_64: 463, aarch64: 463, riscv64: 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] 814 ~   <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] 815 |     { dfd: RawFd, pathname: PathBuf, at_flags: c_uint, name: CString, uargs: Arc<xattr_args> @ sized_by(raw_args.r#usize) } -> c_int
[INFO] [stdout] 816 ~     ~ [File, Desc] for [x86_64: 463, aarch64: 463, riscv64: 463)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:818:3
[INFO] [stdout]     |
[INFO] [stdout] 818 | /   shmat(shmid: c_int, shmaddr: *const c_void, shmflg: c_int) / { shmid: c_int, shmaddr: AddressType, shmflg: c_int } -> AddressType
[INFO] [stdout] 819 | |     ~ [IPC, Memory] for [x86_64: 30, aarch64: 196, riscv64: 196],
[INFO] [stdout]     | |_______________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 818 ~   <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] 819 ~     ~ [IPC, Memory] for [x86_64: 30, aarch64: 196, riscv64: 196)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:822:3
[INFO] [stdout]     |
[INFO] [stdout] 822 |   shmdt(shmaddr: *const c_void) / { shmaddr: AddressType } -> c_int ~ [IPC, Memory] for [x86_64: 67, aarch64: 197, riscv64: 197],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 822 |   <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)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                             +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:830:3
[INFO] [stdout]     |
[INFO] [stdout] 830 | /   signalfd(fd: RawFd, mask: *const sigset_t, size: size_t) / { fd: RawFd, mask: sigset_t, size: size_t } -> c_int
[INFO] [stdout] 831 | |     ~ [Desc, Signal] for [x86_64: 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] 830 ~   <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] 831 ~     ~ [Desc, Signal] for [x86_64: 282)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:832:3
[INFO] [stdout]     |
[INFO] [stdout] 832 | /   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] 833 | |     ~ [Desc, Signal] for [x86_64: 289, aarch64: 74, riscv64: 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] 832 ~   <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] 833 ~     ~ [Desc, Signal] for [x86_64: 289, aarch64: 74, riscv64: 74)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:850:3
[INFO] [stdout]     |
[INFO] [stdout] 850 | /   stat(pathname: *const c_char, statbuf: *mut stat) / { pathname: PathBuf } -> c_int + { statbuf: stat }
[INFO] [stdout] 851 | |     ~ [File, Stat, StatLike] for [x86_64: 4],
[INFO] [stdout]     | |___________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 850 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(stat(pathname: *const c_char, statbuf: *mut stat) / { pathname: PathBuf } -> c_int + { statbuf: stat }
[INFO] [stdout] 851 ~     ~ [File, Stat, StatLike] for [x86_64: 4)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:853:3
[INFO] [stdout]     |
[INFO] [stdout] 853 | /   statfs(path: *const c_char, buf: *mut statfs) / { path: PathBuf } -> c_int + { buf: statfs }
[INFO] [stdout] 854 | |     ~ [File, StatFs, StatFsLike] for [x86_64: 137, aarch64: 43, riscv64: 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] 853 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(statfs(path: *const c_char, buf: *mut statfs) / { path: PathBuf } -> c_int + { buf: statfs }
[INFO] [stdout] 854 ~     ~ [File, StatFs, StatFsLike] for [x86_64: 137, aarch64: 43, riscv64: 43)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:857:3
[INFO] [stdout]     |
[INFO] [stdout] 857 | /   statmount(req: *const mnt_id_req, buf: *mut c_void, bufsize: size_t, flags: c_uint) /
[INFO] [stdout] 858 | |     { req: mnt_id_req, bufsize: size_t, flags: c_uint } -> c_int + { buf: Arc<statmount> @ sized_by(raw_args.bufsize) }
[INFO] [stdout] 859 | |     ~ [] for [x86_64: 457, aarch64: 457, riscv64: 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] 857 ~   <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] 858 |     { req: mnt_id_req, bufsize: size_t, flags: c_uint } -> c_int + { buf: Arc<statmount> @ sized_by(raw_args.bufsize) }
[INFO] [stdout] 859 ~     ~ [] for [x86_64: 457, aarch64: 457, riscv64: 457)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:860:3
[INFO] [stdout]     |
[INFO] [stdout] 860 | /   statx(dirfd: RawFd, pathname: *const c_char, flags: c_int, mask: c_uint, statxbuf: *mut statx) /
[INFO] [stdout] 861 | |     { dirfd: RawFd, pathname: PathBuf, flags: c_int, mask: c_uint } -> c_int + { statxbuf: statx }
[INFO] [stdout] 862 | |     ~ [Desc, File, FStat, StatLike] for [x86_64: 332, aarch64: 291, riscv64: 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] 860 ~   <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] 861 |     { dirfd: RawFd, pathname: PathBuf, flags: c_int, mask: c_uint } -> c_int + { statxbuf: statx }
[INFO] [stdout] 862 ~     ~ [Desc, File, FStat, StatLike] for [x86_64: 332, aarch64: 291, riscv64: 291)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:872:3
[INFO] [stdout]     |
[INFO] [stdout] 872 | /   symlinkat(target: *const c_char, newdirfd: RawFd, linkpath: *const c_char) /
[INFO] [stdout] 873 | |     { target: PathBuf, newdirfd: RawFd, linkpath: PathBuf } -> c_int
[INFO] [stdout] 874 | |     ~ [Desc, File] for [x86_64: 266, aarch64: 36, riscv64: 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] 872 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(symlinkat(target: *const c_char, newdirfd: RawFd, linkpath: *const c_char) /
[INFO] [stdout] 873 |     { target: PathBuf, newdirfd: RawFd, linkpath: PathBuf } -> c_int
[INFO] [stdout] 874 ~     ~ [Desc, File] for [x86_64: 266, aarch64: 36, riscv64: 36)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:876:3
[INFO] [stdout]     |
[INFO] [stdout] 876 |   sync() / {} -> c_int ~ [] for [x86_64: 162, aarch64: 81, riscv64: 81],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 876 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(sync() / {} -> c_int ~ [] for [x86_64: 162, aarch64: 81, riscv64: 81)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:884:3
[INFO] [stdout]     |
[INFO] [stdout] 884 | /   sysfs(option: c_int, arg1: c_ulong, arg2: c_ulong) / { option: c_int, arg1: c_ulong, arg2: c_ulong } -> c_int
[INFO] [stdout] 885 | |     ~ [] for [x86_64: 139],
[INFO] [stdout]     | |_________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 884 ~   <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] 885 ~     ~ [] for [x86_64: 139)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:886:3
[INFO] [stdout]     |
[INFO] [stdout] 886 |   sysinfo(info: *mut sysinfo) / { } -> c_int + { info: sysinfo } ~ [] for [x86_64: 99, aarch64: 179, riscv64: 179],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 886 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(sysinfo(info: *mut sysinfo) / { } -> c_int + { info: sysinfo } ~ [] for [x86_64: 99, aarch64: 179, riscv64: 179)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                               +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:887:3
[INFO] [stdout]     |
[INFO] [stdout] 887 | /   syslog(typ: c_int, buf: *const c_char, len: c_int) / { typ: c_int, buf: CString, len: c_int } -> c_int
[INFO] [stdout] 888 | |     ~ [] for [x86_64: 103, aarch64: 116, riscv64: 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] 887 ~   <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] 888 ~     ~ [] for [x86_64: 103, aarch64: 116, riscv64: 116)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:892:3
[INFO] [stdout]     |
[INFO] [stdout] 892 | /   tgkill(tgid: pid_t, tid: pid_t, sig: c_int) / { tgid: pid_t, tid: pid_t, sig: c_int } -> c_int
[INFO] [stdout] 893 | |     ~ [Signal, Process] for [x86_64: 234, aarch64: 131, riscv64: 131],
[INFO] [stdout]     | |____________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 892 ~   <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] 893 ~     ~ [Signal, Process] for [x86_64: 234, aarch64: 131, riscv64: 131)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:895:3
[INFO] [stdout]     |
[INFO] [stdout] 895 | /   timer_create(clockid: clockid_t, sevp: *const sigevent, timerid: *mut timer_t) /
[INFO] [stdout] 896 | |     { clockid: clockid_t, sevp: Option<sigevent> } -> c_int + { timerid: InspectResult<timer_t> }
[INFO] [stdout] 897 | |     ~ [] for [x86_64: 222, aarch64: 107, riscv64: 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] 895 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(timer_create(clockid: clockid_t, sevp: *const sigevent, timerid: *mut timer_t) /
[INFO] [stdout] 896 |     { clockid: clockid_t, sevp: Option<sigevent> } -> c_int + { timerid: InspectResult<timer_t> }
[INFO] [stdout] 897 ~     ~ [] for [x86_64: 222, aarch64: 107, riscv64: 107)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:898:3
[INFO] [stdout]     |
[INFO] [stdout] 898 |   timer_delete(timerid: timer_t) / { timerid: timer_t } -> c_int ~ [] for [x86_64: 226, aarch64: 111, riscv64: 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] 898 |   <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)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:899:3
[INFO] [stdout]     |
[INFO] [stdout] 899 |   timer_getoverrun(timerid: timer_t) / { timerid: timer_t } -> c_int ~ [] for [x86_64: 225, aarch64: 109, riscv64: 109],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 899 |   <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)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:900:3
[INFO] [stdout]     |
[INFO] [stdout] 900 | /   timer_gettime(timerid: timer_t, curr_value: *mut itimerspec) / { timerid: timer_t } -> c_int + { curr_value: itimerspec }
[INFO] [stdout] 901 | |     ~ [] for [x86_64: 224, aarch64: 108, riscv64: 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] 900 ~   <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] 901 ~     ~ [] for [x86_64: 224, aarch64: 108, riscv64: 108)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:903:3
[INFO] [stdout]     |
[INFO] [stdout] 903 | /   timer_settime(timerid: timer_t, flags: c_int, new_value: *const itimerspec, old_value: *mut itimerspec) /
[INFO] [stdout] 904 | |     { timerid: timer_t, flags: c_int, new_value: itimerspec } -> c_int + { old_value: Option<itimerspec> }
[INFO] [stdout] 905 | |     ~ [] for [x86_64: 223, aarch64: 110, riscv64: 110],
[INFO] [stdout]     | |_____________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 903 ~   <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] 904 |     { timerid: timer_t, flags: c_int, new_value: itimerspec } -> c_int + { old_value: Option<itimerspec> }
[INFO] [stdout] 905 ~     ~ [] for [x86_64: 223, aarch64: 110, riscv64: 110)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:917:3
[INFO] [stdout]     |
[INFO] [stdout] 917 |   times(buf: *mut tms) / { } -> clock_t + { buf: tms } ~ [] for [x86_64: 100, aarch64: 153, riscv64: 153],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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(times(buf: *mut tms) / { } -> clock_t + { buf: tms } ~ [] for [x86_64: 100, aarch64: 153, riscv64: 153)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:918:3
[INFO] [stdout]     |
[INFO] [stdout] 918 |   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],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 918 |   <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)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:923:3
[INFO] [stdout]     |
[INFO] [stdout] 923 |   umask(mask: mode_t) / { mask: mode_t } -> mode_t ~ [] for [x86_64: 95, aarch64: 166, riscv64: 166],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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(umask(mask: mode_t) / { mask: mode_t } -> mode_t ~ [] for [x86_64: 95, aarch64: 166, riscv64: 166)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:927:3
[INFO] [stdout]     |
[INFO] [stdout] 927 |   uname(buf: *mut utsname) / { } -> c_int + { buf: utsname } ~ [] for [x86_64: 63, aarch64: 160, riscv64: 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] 927 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(uname(buf: *mut utsname) / { } -> c_int + { buf: utsname } ~ [] for [x86_64: 63, aarch64: 160, riscv64: 160)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:929:3
[INFO] [stdout]     |
[INFO] [stdout] 929 | /   unlinkat(dirfd: RawFd, pathname: *const c_char, flags: c_int) / { dirfd: RawFd, pathname: PathBuf, flags: c_int } -> c_int
[INFO] [stdout] 930 | |     ~ [Desc, File] for [x86_64: 263, aarch64: 35, riscv64: 35],
[INFO] [stdout]     | |_____________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 929 ~   <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] 930 ~     ~ [Desc, File] for [x86_64: 263, aarch64: 35, riscv64: 35)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:931:3
[INFO] [stdout]     |
[INFO] [stdout] 931 |   unshare(flags: c_int) / { flags: c_int } -> c_int ~ [] for [x86_64: 272, aarch64: 97, riscv64: 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] 931 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(unshare(flags: c_int) / { flags: c_int } -> c_int ~ [] for [x86_64: 272, aarch64: 97, riscv64: 97)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:932:3
[INFO] [stdout]     |
[INFO] [stdout] 932 |   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] 932 |   <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>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:934:3
[INFO] [stdout]     |
[INFO] [stdout] 934 |   ustat(dev: dev_t, ubuf: *mut ustat) / { dev: dev_t } -> c_int + { ubuf: ustat } ~ [] for [x86_64: 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] 934 |   <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)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:937:3
[INFO] [stdout]     |
[INFO] [stdout] 937 | /   utimensat(dirfd: RawFd, pathname: *const c_char, times: *const timespec, flags: c_int) /
[INFO] [stdout] 938 | |     { dirfd: RawFd, pathname: PathBuf, times: Option<[timespec; 2]>, flags: c_int } -> c_int
[INFO] [stdout] 939 | |     ~ [Desc, File] for [x86_64: 280, aarch64: 88, riscv64: 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] 937 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(utimensat(dirfd: RawFd, pathname: *const c_char, times: *const timespec, flags: c_int) /
[INFO] [stdout] 938 |     { dirfd: RawFd, pathname: PathBuf, times: Option<[timespec; 2]>, flags: c_int } -> c_int
[INFO] [stdout] 939 ~     ~ [Desc, File] for [x86_64: 280, aarch64: 88, riscv64: 88)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:945:3
[INFO] [stdout]     |
[INFO] [stdout] 945 |   vhangup() / {} -> c_int ~ [] for [x86_64: 153, aarch64: 58, riscv64: 58],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 945 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(vhangup() / {} -> c_int ~ [] for [x86_64: 153, aarch64: 58, riscv64: 58)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]   --> src/syscalls.rs:78:3
[INFO] [stdout]    |
[INFO] [stdout] 78 | /   add_key(r#type: *const c_char, description: *const c_char, payload: *const c_void, plen: size_t, keyring: key_serial_t ) /
[INFO] [stdout] 79 | |     { r#type: CString, description: CString, payload: Vec<u8> @ counted_by(raw_args.plen), keyring: key_serial_t }
[INFO] [stdout] 80 | |     -> key_serial_t ~ [] for [x86_64: 248, aarch64: 217, riscv64: 217],
[INFO] [stdout]    | |_____________________________________________________________________^
[INFO] [stdout]    |
[INFO] [stdout]    = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is 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] 78 ~   <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] 79 |     { r#type: CString, description: CString, payload: Vec<u8> @ counted_by(raw_args.plen), keyring: key_serial_t }
[INFO] [stdout] 80 ~     -> key_serial_t ~ [] for [x86_64: 248, aarch64: 217, riscv64: 217)],
[INFO] [stdout]    |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]   --> src/syscalls.rs:82:3
[INFO] [stdout]    |
[INFO] [stdout] 82 |   alarm(seconds: c_uint) / { seconds: c_uint } -> c_uint ~ [] for [x86_64: 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] 82 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(alarm(seconds: c_uint) / { seconds: c_uint } -> c_uint ~ [] for [x86_64: 37)],
[INFO] [stdout]    |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]   --> src/syscalls.rs:84:3
[INFO] [stdout]    |
[INFO] [stdout] 84 |   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] 84 |   <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>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:115:3
[INFO] [stdout]     |
[INFO] [stdout] 115 | /   clock_nanosleep(clockid: clockid_t, flags: c_int, request: *const timespec, remain: *mut timespec) /
[INFO] [stdout] 116 | |   { clockid: clockid_t, flags: c_int, request: timespec } -> c_int + { remain: Option<timespec> }
[INFO] [stdout] 117 | |     ~ [] for [x86_64: 230, aarch64: 115, riscv64: 115],
[INFO] [stdout]     | |_____________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 115 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(clock_nanosleep(clockid: clockid_t, flags: c_int, request: *const timespec, remain: *mut timespec) /
[INFO] [stdout] 116 |   { clockid: clockid_t, flags: c_int, request: timespec } -> c_int + { remain: Option<timespec> }
[INFO] [stdout] 117 ~     ~ [] for [x86_64: 230, aarch64: 115, riscv64: 115)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:131:3
[INFO] [stdout]     |
[INFO] [stdout] 131 | /   close_range(first: c_uint, last: c_uint, flags: c_uint) / { first: c_uint, last: c_uint, flags: c_uint }
[INFO] [stdout] 132 | |     -> c_int ~ [] for [x86_64: 436, aarch64: 436, riscv64: 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] 131 ~   <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] 132 ~     -> c_int ~ [] for [x86_64: 436, aarch64: 436, riscv64: 436)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:138:3
[INFO] [stdout]     |
[INFO] [stdout] 138 |   creat(pathname: *const c_char, mode: mode_t) / { pathname: PathBuf, mode: mode_t } -> RawFd ~ [Desc, File] for [x86_64: 85],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 138 |   <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)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                          +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:139:3
[INFO] [stdout]     |
[INFO] [stdout] 139 |   delete_module(name: *const c_char, flags: c_uint) / { name: CString, flags: c_uint } -> c_int ~ [] for [x86_64: 176, aarch64: 106, riscv64: 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] 139 |   <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)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                               +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:167:3
[INFO] [stdout]     |
[INFO] [stdout] 167 | /   execve(filename: *const c_char, argv: *const *const c_char, envp: *const *const c_char) /
[INFO] [stdout] 168 | |     { filename: PathBuf, argv: Option<Vec<CString>>, envp: Option<Vec<CString>> } -> c_int
[INFO] [stdout] 169 | |     ~ [File, Process] for [x86_64: 59, aarch64: 221, riscv64: 221],
[INFO] [stdout]     | |_________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 167 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(execve(filename: *const c_char, argv: *const *const c_char, envp: *const *const c_char) /
[INFO] [stdout] 168 |     { filename: PathBuf, argv: Option<Vec<CString>>, envp: Option<Vec<CString>> } -> c_int
[INFO] [stdout] 169 ~     ~ [File, Process] for [x86_64: 59, aarch64: 221, riscv64: 221)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:170:3
[INFO] [stdout]     |
[INFO] [stdout] 170 | /   execveat(dirfd: RawFd, pathname: *const c_char, argv: *const *const c_char, envp: *const *const c_char, flags: c_int) /
[INFO] [stdout] 171 | |     { dirfd: RawFd, pathname: PathBuf, argv: Option<Vec<CString>>, envp: Option<Vec<CString>>, flags: c_int }
[INFO] [stdout] 172 | |     -> c_int ~ [Desc, File, Process] for [x86_64: 322, aarch64: 281, riscv64: 281],
[INFO] [stdout]     | |_________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 170 ~   <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] 171 |     { dirfd: RawFd, pathname: PathBuf, argv: Option<Vec<CString>>, envp: Option<Vec<CString>>, flags: c_int }
[INFO] [stdout] 172 ~     -> c_int ~ [Desc, File, Process] for [x86_64: 322, aarch64: 281, riscv64: 281)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:175:3
[INFO] [stdout]     |
[INFO] [stdout] 175 | /   faccessat(dirfd: RawFd, pathname: *const c_char, mode: c_int) /
[INFO] [stdout] 176 | |     { dirfd: RawFd, pathname: PathBuf, mode: c_int } -> c_int ~ [Desc, File] for [x86_64: 269, aarch64: 48, riscv64: 48],
[INFO] [stdout]     | |_______________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 175 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(faccessat(dirfd: RawFd, pathname: *const c_char, mode: c_int) /
[INFO] [stdout] 176 ~     { dirfd: RawFd, pathname: PathBuf, mode: c_int } -> c_int ~ [Desc, File] for [x86_64: 269, aarch64: 48, riscv64: 48)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:177:3
[INFO] [stdout]     |
[INFO] [stdout] 177 | /   faccessat2(dirfd: RawFd, pathname: *const c_char, mode: c_int, flags: c_int) /
[INFO] [stdout] 178 | |     { dirfd: RawFd, pathname: PathBuf, mode: c_int, flags: c_int } -> c_int ~ [Desc, File] for [x86_64: 439, aarch64: 439, riscv64: 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] 177 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(faccessat2(dirfd: RawFd, pathname: *const c_char, mode: c_int, flags: c_int) /
[INFO] [stdout] 178 ~     { dirfd: RawFd, pathname: PathBuf, mode: c_int, flags: c_int } -> c_int ~ [Desc, File] for [x86_64: 439, aarch64: 439, riscv64: 439)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:187:3
[INFO] [stdout]     |
[INFO] [stdout] 187 | /   fanotify_mark(fanotify_fd: RawFd, flags: c_uint, mask: u64, dirfd: RawFd, pathname: *const c_char) /
[INFO] [stdout] 188 | |     { 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],
[INFO] [stdout]     | |__________________________________________________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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(fanotify_mark(fanotify_fd: RawFd, flags: c_uint, mask: u64, dirfd: RawFd, pathname: *const c_char) /
[INFO] [stdout] 188 ~     { 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)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:191:3
[INFO] [stdout]     |
[INFO] [stdout] 191 | /   fchmodat(dirfd: RawFd, pathname: *const c_char, mode: mode_t) /
[INFO] [stdout] 192 | |     { dirfd: RawFd, pathname: PathBuf, mode: mode_t } -> c_int ~ [Desc, File] for [x86_64: 268, aarch64: 53, riscv64: 53],
[INFO] [stdout]     | |________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 191 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(fchmodat(dirfd: RawFd, pathname: *const c_char, mode: mode_t) /
[INFO] [stdout] 192 ~     { dirfd: RawFd, pathname: PathBuf, mode: mode_t } -> c_int ~ [Desc, File] for [x86_64: 268, aarch64: 53, riscv64: 53)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:193:3
[INFO] [stdout]     |
[INFO] [stdout] 193 | /   fchmodat2(dirfd: RawFd, pathname: *const c_char, mode: mode_t, flags: c_int) /
[INFO] [stdout] 194 | |     { dirfd: RawFd, pathname: PathBuf, mode: mode_t, flags: c_int } -> c_int ~ [Desc, File] for [x86_64: 452, aarch64: 452, riscv64: 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] 193 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(fchmodat2(dirfd: RawFd, pathname: *const c_char, mode: mode_t, flags: c_int) /
[INFO] [stdout] 194 ~     { dirfd: RawFd, pathname: PathBuf, mode: mode_t, flags: c_int } -> c_int ~ [Desc, File] for [x86_64: 452, aarch64: 452, riscv64: 452)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:197:3
[INFO] [stdout]     |
[INFO] [stdout] 197 | /   fchownat(dirfd: RawFd, pathname: *const c_char, owner: uid_t, group: gid_t, flags: c_int) /
[INFO] [stdout] 198 | |     { 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],
[INFO] [stdout]     | |____________________________________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 197 ~   <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] 198 ~     { 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)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:212:3
[INFO] [stdout]     |
[INFO] [stdout] 212 | /   fsconfig(fd: RawFd, cmd: c_uint, key: *const c_char, value: *const c_char, aux: c_int) /
[INFO] [stdout] 213 | |     { fd: RawFd, cmd: c_uint, key: CString, value: CString, aux: c_int } -> c_int ~ [Desc, File] for [x86_64: 431, aarch64: 431, riscv64: 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] 212 ~   <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] 213 ~     { fd: RawFd, cmd: c_uint, key: CString, value: CString, aux: c_int } -> c_int ~ [Desc, File] for [x86_64: 431, aarch64: 431, riscv64: 431)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:220:3
[INFO] [stdout]     |
[INFO] [stdout] 220 | /   fspick(dirfd: RawFd, pathname: *const c_char, flags: c_uint) / { dirfd: RawFd, pathname: CString, flags: c_uint } -> c_int
[INFO] [stdout] 221 | |     ~ [Desc, File] for [x86_64: 433, aarch64: 433, riscv64: 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] 220 ~   <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] 221 ~     ~ [Desc, File] for [x86_64: 433, aarch64: 433, riscv64: 433)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:222:3
[INFO] [stdout]     |
[INFO] [stdout] 222 |   fstat(fd: RawFd, statbuf: *mut stat) / { fd: RawFd } -> c_int + { statbuf: stat } ~ [Desc, FStat, StatLike] for [x86_64: 5, aarch64: 80, riscv64: 80],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 222 |   <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)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                                    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:224:3
[INFO] [stdout]     |
[INFO] [stdout] 224 |   fstatfs(fd: RawFd, buf: *mut statfs) / { fd: RawFd } -> c_int + { buf: statfs } ~ [Desc, FStatFs, StatFsLike] for [x86_64: 138, aarch64: 44, riscv64: 44],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 224 |   <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)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                                        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:230:3
[INFO] [stdout]     |
[INFO] [stdout] 230 | /   futex(uaddr: *mut u32, futex_op: c_int, val: u32, val2: usize, uaddr2: *mut u32, val3: u32) /
[INFO] [stdout] 231 | |     { uaddr: InspectResult<u32>, futex_op: c_int, val: u32, val2: usize, uaddr2: InspectResult<u32>, val3: u32 }
[INFO] [stdout] 232 | |     -> c_long + { uaddr: InspectResult<u32>, uaddr2: InspectResult<u32> } ~ [] for [x86_64: 202, aarch64: 98, riscv64: 98],
[INFO] [stdout]     | |_________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 230 ~   <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] 231 |     { uaddr: InspectResult<u32>, futex_op: c_int, val: u32, val2: usize, uaddr2: InspectResult<u32>, val3: u32 }
[INFO] [stdout] 232 ~     -> c_long + { uaddr: InspectResult<u32>, uaddr2: InspectResult<u32> } ~ [] for [x86_64: 202, aarch64: 98, riscv64: 98)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:235:3
[INFO] [stdout]     |
[INFO] [stdout] 235 | /   futex_requeue(waiters: *mut futex_waitv, flags: c_uint, nr_wake: c_int, nr_requeue: c_int) /
[INFO] [stdout] 236 | |     { waiters: [futex_waitv; 2], flags: c_uint, nr_wake: c_int, nr_requeue: c_int }
[INFO] [stdout] 237 | |     -> c_long + { waiters: [futex_waitv; 2] } ~ [] for [x86_64: 456, aarch64: 456, riscv64: 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] 235 ~   <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] 236 |     { waiters: [futex_waitv; 2], flags: c_uint, nr_wake: c_int, nr_requeue: c_int }
[INFO] [stdout] 237 ~     -> c_long + { waiters: [futex_waitv; 2] } ~ [] for [x86_64: 456, aarch64: 456, riscv64: 456)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:239:3
[INFO] [stdout]     |
[INFO] [stdout] 239 | /   futex_wait(uaddr: *mut u32, val: c_ulong, mask: c_ulong, flags: c_uint, timespec: *mut timespec, clockid: clockid_t) /
[INFO] [stdout] 240 | |     { uaddr: InspectResult<u32>, val: c_ulong, mask: c_ulong, flags: c_uint, timespec: timespec, clockid: clockid_t }
[INFO] [stdout] 241 | |     -> c_long + { uaddr: InspectResult<u32> } ~ [] for [x86_64: 455, aarch64: 455, riscv64: 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] 239 ~   <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] 240 |     { uaddr: InspectResult<u32>, val: c_ulong, mask: c_ulong, flags: c_uint, timespec: timespec, clockid: clockid_t }
[INFO] [stdout] 241 ~     -> c_long + { uaddr: InspectResult<u32> } ~ [] for [x86_64: 455, aarch64: 455, riscv64: 455)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:242:3
[INFO] [stdout]     |
[INFO] [stdout] 242 | /   futex_waitv(waiters: *mut futex_waitv, nr_futexes: c_uint, flags: c_uint, timeout: *mut timespec, clockid: clockid_t) /
[INFO] [stdout] 243 | |     { waiters: Vec<futex_waitv> @ counted_by(raw_args.nr_futexes), flags: c_uint, timeout: timespec, clockid: clockid_t }
[INFO] [stdout] 244 | |     -> c_long + { waiters: Vec<futex_waitv> @ counted_by(raw_args.nr_futexes) } ~ [] for [x86_64: 449, aarch64: 449, riscv64: 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] 242 ~   <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] 243 |     { waiters: Vec<futex_waitv> @ counted_by(raw_args.nr_futexes), flags: c_uint, timeout: timespec, clockid: clockid_t }
[INFO] [stdout] 244 ~     -> c_long + { waiters: Vec<futex_waitv> @ counted_by(raw_args.nr_futexes) } ~ [] for [x86_64: 449, aarch64: 449, riscv64: 449)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:245:3
[INFO] [stdout]     |
[INFO] [stdout] 245 | /   futex_wake(uaddr: *mut u32, mask: c_ulong, nr: c_int, flags: c_uint) /
[INFO] [stdout] 246 | |     { uaddr: InspectResult<u32>, mask: c_ulong, nr: c_int, flags: c_uint }
[INFO] [stdout] 247 | |     -> c_long + { uaddr: InspectResult<u32> } ~ [] for [x86_64: 454, aarch64: 454, riscv64: 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] 245 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(futex_wake(uaddr: *mut u32, mask: c_ulong, nr: c_int, flags: c_uint) /
[INFO] [stdout] 246 |     { uaddr: InspectResult<u32>, mask: c_ulong, nr: c_int, flags: c_uint }
[INFO] [stdout] 247 ~     -> c_long + { uaddr: InspectResult<u32> } ~ [] for [x86_64: 454, aarch64: 454, riscv64: 454)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:248:3
[INFO] [stdout]     |
[INFO] [stdout] 248 | /   futimesat(dirfd: RawFd, pathname: *const c_char, times: *const timeval) /
[INFO] [stdout] 249 | |     { dirfd: RawFd, pathname: PathBuf, times: [timeval;2] } -> c_int ~ [Desc, File] for [x86_64: 261],
[INFO] [stdout]     | |____________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 248 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(futimesat(dirfd: RawFd, pathname: *const c_char, times: *const timeval) /
[INFO] [stdout] 249 ~     { dirfd: RawFd, pathname: PathBuf, times: [timeval;2] } -> c_int ~ [Desc, File] for [x86_64: 261)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:256:3
[INFO] [stdout]     |
[INFO] [stdout] 256 | /   get_robust_list(pid: pid_t, head_ptr: *mut *mut robust_list_head, len_ptr: *mut size_t) /
[INFO] [stdout] 257 | |     { pid: pid_t, head_ptr: InspectResult<AddressType>, len_ptr: size_t } -> c_long ~ [] for [x86_64: 274, aarch64: 100, riscv64: 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] 256 ~   <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] 257 ~     { pid: pid_t, head_ptr: InspectResult<AddressType>, len_ptr: size_t } -> c_long ~ [] for [x86_64: 274, aarch64: 100, riscv64: 100)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:258:3
[INFO] [stdout]     |
[INFO] [stdout] 258 |   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] 258 |   <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>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:259:3
[INFO] [stdout]     |
[INFO] [stdout] 259 | /   getcpu(cpu: *mut c_uint, node: *mut c_uint) /
[INFO] [stdout] 260 | |     { cpu: InspectResult<Option<c_uint>>, node: InspectResult<Option<c_uint>> } -> c_int ~ [] for [x86_64: 309, aarch64: 168, riscv64: 168],
[INFO] [stdout]     | |__________________________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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(getcpu(cpu: *mut c_uint, node: *mut c_uint) /
[INFO] [stdout] 260 ~     { cpu: InspectResult<Option<c_uint>>, node: InspectResult<Option<c_uint>> } -> c_int ~ [] for [x86_64: 309, aarch64: 168, riscv64: 168)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:271:3
[INFO] [stdout]     |
[INFO] [stdout] 271 |   getegid() / {} -> gid_t ~ [Creds, Pure] for [x86_64: 108, aarch64: 177, riscv64: 177],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 271 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(getegid() / {} -> gid_t ~ [Creds, Pure] for [x86_64: 108, aarch64: 177, riscv64: 177)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:273:3
[INFO] [stdout]     |
[INFO] [stdout] 273 |   geteuid() / {} -> uid_t ~ [Creds, Pure] for [x86_64: 107, aarch64: 175, riscv64: 175],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 273 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(geteuid() / {} -> uid_t ~ [Creds, Pure] for [x86_64: 107, aarch64: 175, riscv64: 175)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:275:3
[INFO] [stdout]     |
[INFO] [stdout] 275 |   getgid() / {} -> gid_t ~ [Creds, Pure] for [x86_64: 104, aarch64: 176, riscv64: 176],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 275 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(getgid() / {} -> gid_t ~ [Creds, Pure] for [x86_64: 104, aarch64: 176, riscv64: 176)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:282:3
[INFO] [stdout]     |
[INFO] [stdout] 282 |   getitimer(which: c_int, value: *mut itimerval) / { which: c_int } -> c_int + { value: itimerval } ~ [] for [x86_64: 36, aarch64: 102, riscv64: 102],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 282 |   <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)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                                  +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:287:3
[INFO] [stdout]     |
[INFO] [stdout] 287 |   getpgid(pid: pid_t) / { pid: pid_t } -> pid_t ~ [] for [x86_64: 121, aarch64: 155, riscv64: 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] 287 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(getpgid(pid: pid_t) / { pid: pid_t } -> pid_t ~ [] for [x86_64: 121, aarch64: 155, riscv64: 155)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                               +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:291:3
[INFO] [stdout]     |
[INFO] [stdout] 291 |   getpriority(which: c_int, who: id_t) / { which: c_int, who: id_t } -> c_int ~ [] for [x86_64: 140, aarch64: 141, riscv64: 141],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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(getpriority(which: c_int, who: id_t) / { which: c_int, who: id_t } -> c_int ~ [] for [x86_64: 140, aarch64: 141, riscv64: 141)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                             +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:292:3
[INFO] [stdout]     |
[INFO] [stdout] 292 | /   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] 293 | |     ~ [] for [x86_64: 318, aarch64: 278, riscv64: 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] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 292 ~   <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] 293 ~     ~ [] for [x86_64: 318, aarch64: 278, riscv64: 278)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:302:3
[INFO] [stdout]     |
[INFO] [stdout] 302 |   getrlimit(resource: c_int, rlim: *mut rlimit) / { resource: c_int } -> c_int + { rlim: rlimit } ~ [] for [x86_64: 97, aarch64: 163, riscv64: 163],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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(getrlimit(resource: c_int, rlim: *mut rlimit) / { resource: c_int } -> c_int + { rlim: rlimit } ~ [] for [x86_64: 97, aarch64: 163, riscv64: 163)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                                +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:303:3
[INFO] [stdout]     |
[INFO] [stdout] 303 |   getrusage(who: c_int, usage: *mut rusage) / { who: c_int } -> c_int + { usage: rusage } ~ [] for [x86_64: 98, aarch64: 165, riscv64: 165],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 303 |   <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)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:304:3
[INFO] [stdout]     |
[INFO] [stdout] 304 |   getsid(pid: pid_t) / { pid: pid_t } -> pid_t ~ [] for [x86_64: 124, aarch64: 156, riscv64: 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] 304 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(getsid(pid: pid_t) / { pid: pid_t } -> pid_t ~ [] for [x86_64: 124, aarch64: 156, riscv64: 156)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                              +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:314:3
[INFO] [stdout]     |
[INFO] [stdout] 314 |   getuid() / {} -> uid_t ~ [Creds, Pure] for [x86_64: 102, aarch64: 174, riscv64: 174],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 314 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(getuid() / {} -> uid_t ~ [Creds, Pure] for [x86_64: 102, aarch64: 174, riscv64: 174)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:319:3
[INFO] [stdout]     |
[INFO] [stdout] 319 | /   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] 320 | |     { 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],
[INFO] [stdout]     | |__________________________________________________________________________________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 319 ~   <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] 320 ~     { 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)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:324:3
[INFO] [stdout]     |
[INFO] [stdout] 324 | /   init_module(module_image: *mut c_void, len: c_ulong, param_values: *const c_char) /
[INFO] [stdout] 325 | |     { module_image: Vec<u8> @ counted_by(raw_args.len), param_values: CString } -> c_int ~ [] for [x86_64: 175, aarch64: 105, riscv64: 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] 324 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(init_module(module_image: *mut c_void, len: c_ulong, param_values: *const c_char) /
[INFO] [stdout] 325 ~     { module_image: Vec<u8> @ counted_by(raw_args.len), param_values: CString } -> c_int ~ [] for [x86_64: 175, aarch64: 105, riscv64: 105)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:326:3
[INFO] [stdout]     |
[INFO] [stdout] 326 | /   inotify_add_watch(fd: RawFd, pathname: *const c_char, mask: u32) /
[INFO] [stdout] 327 | |     { fd: RawFd, pathname: PathBuf, mask: u32 } -> c_int ~ [Desc, File] for [x86_64: 254, aarch64: 27, riscv64: 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] 326 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(inotify_add_watch(fd: RawFd, pathname: *const c_char, mask: u32) /
[INFO] [stdout] 327 ~     { fd: RawFd, pathname: PathBuf, mask: u32 } -> c_int ~ [Desc, File] for [x86_64: 254, aarch64: 27, riscv64: 27)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:331:3
[INFO] [stdout]     |
[INFO] [stdout] 331 | /   io_cancel(ctx_id: aio_context_t, iocb: *mut iocb, result: *mut io_event) /
[INFO] [stdout] 332 | |     { ctx_id: aio_context_t, iocb: iocb } -> c_int + { result: io_event } ~ [] for [x86_64: 210, aarch64: 3, riscv64: 3],
[INFO] [stdout]     | |_______________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 331 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(io_cancel(ctx_id: aio_context_t, iocb: *mut iocb, result: *mut io_event) /
[INFO] [stdout] 332 ~     { ctx_id: aio_context_t, iocb: iocb } -> c_int + { result: io_event } ~ [] for [x86_64: 210, aarch64: 3, riscv64: 3)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:334:3
[INFO] [stdout]     |
[INFO] [stdout] 334 |   io_destroy(ctx_id: aio_context_t) / { ctx_id: aio_context_t } -> c_int ~ [] for [x86_64: 207, aarch64: 1, riscv64: 1],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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(io_destroy(ctx_id: aio_context_t) / { ctx_id: aio_context_t } -> c_int ~ [] for [x86_64: 207, aarch64: 1, riscv64: 1)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:336:3
[INFO] [stdout]     |
[INFO] [stdout] 336 | /   io_getevents(ctx_id: aio_context_t, min_nr: c_long, nr: c_long, events: *mut io_event, timeout: *mut timespec) /
[INFO] [stdout] 337 | |     { ctx_id: aio_context_t, min_nr: c_long, nr: c_long, timeout: Option<timespec> }
[INFO] [stdout] 338 | |     -> c_int + { events: Vec<io_event> @ counted_by(syscall_result) } ~ [] for [x86_64: 208, aarch64: 4, riscv64: 4],
[INFO] [stdout]     | |___________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 336 ~   <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] 337 |     { ctx_id: aio_context_t, min_nr: c_long, nr: c_long, timeout: Option<timespec> }
[INFO] [stdout] 338 ~     -> c_int + { events: Vec<io_event> @ counted_by(syscall_result) } ~ [] for [x86_64: 208, aarch64: 4, riscv64: 4)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:339:3
[INFO] [stdout]     |
[INFO] [stdout] 339 | /   io_pgetevents(ctx_id: aio_context_t, min_nr: c_long, nr: c_long, events: *mut io_event, timeout: *mut timespec, sig: *const __a...
[INFO] [stdout] 340 | |     { ctx_id: aio_context_t, min_nr: c_long, nr: c_long, timeout: Option<timespec>, sig: __aio_sigset }
[INFO] [stdout] 341 | |     -> c_int + { events: Vec<io_event> @ counted_by(syscall_result) } ~ [] for [x86_64: 333, aarch64: 292, riscv64: 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] 339 ~   <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] 340 |     { ctx_id: aio_context_t, min_nr: c_long, nr: c_long, timeout: Option<timespec>, sig: __aio_sigset }
[INFO] [stdout] 341 ~     -> c_int + { events: Vec<io_event> @ counted_by(syscall_result) } ~ [] for [x86_64: 333, aarch64: 292, riscv64: 292)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:346:3
[INFO] [stdout]     |
[INFO] [stdout] 346 | /   io_submit(ctx: aio_context_t, nr: c_long, iocbs: *mut *mut iocb) /
[INFO] [stdout] 347 | |     { ctx: aio_context_t, iocbs: Vec<AddressType> @ counted_by(raw_args.nr) } -> c_int ~ [] for [x86_64: 209, aarch64: 2, riscv64: 2],
[INFO] [stdout]     | |____________________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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(io_submit(ctx: aio_context_t, nr: c_long, iocbs: *mut *mut iocb) /
[INFO] [stdout] 347 ~     { ctx: aio_context_t, iocbs: Vec<AddressType> @ counted_by(raw_args.nr) } -> c_int ~ [] for [x86_64: 209, aarch64: 2, riscv64: 2)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:349:3
[INFO] [stdout]     |
[INFO] [stdout] 349 | /   io_uring_enter(fd: c_uint, to_submit: c_uint, min_complete: c_uint, flags: c_uint, arg: AddressType, argsz: size_t) /
[INFO] [stdout] 350 | |     { fd: c_uint, to_submit: c_uint, min_complete: c_uint, flags: c_uint, arg: Vec<u8> @ counted_by(raw_args.argsz) }
[INFO] [stdout] 351 | |     -> c_int ~ [Desc, File] for [x86_64: 426, aarch64: 426, riscv64: 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] 349 ~   <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] 350 |     { fd: c_uint, to_submit: c_uint, min_complete: c_uint, flags: c_uint, arg: Vec<u8> @ counted_by(raw_args.argsz) }
[INFO] [stdout] 351 ~     -> c_int ~ [Desc, File] for [x86_64: 426, aarch64: 426, riscv64: 426)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:353:3
[INFO] [stdout]     |
[INFO] [stdout] 353 | /   io_uring_register(fd: c_uint, op: c_uint, arg: AddressType, nr_args: c_uint) /
[INFO] [stdout] 354 | |     { fd: c_uint, op: c_uint, arg: AddressType, nr_args: c_uint } -> c_int ~ [Desc, Memory] for [x86_64: 427, aarch64: 427, riscv64: 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] 353 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(io_uring_register(fd: c_uint, op: c_uint, arg: AddressType, nr_args: c_uint) /
[INFO] [stdout] 354 ~     { fd: c_uint, op: c_uint, arg: AddressType, nr_args: c_uint } -> c_int ~ [Desc, Memory] for [x86_64: 427, aarch64: 427, riscv64: 427)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:359:3
[INFO] [stdout]     |
[INFO] [stdout] 359 |   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] 359 |   <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>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:360:3
[INFO] [stdout]     |
[INFO] [stdout] 360 |   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] 360 |   <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>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:361:3
[INFO] [stdout]     |
[INFO] [stdout] 361 |   ioprio_get(which: c_int, who: c_int) / { which: c_int, who: c_int } -> c_int ~ [] for [x86_64: 252, aarch64: 31, riscv64: 31],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 361 |   <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)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:362:3
[INFO] [stdout]     |
[INFO] [stdout] 362 |   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],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 362 |   <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)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                                          +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:364:3
[INFO] [stdout]     |
[INFO] [stdout] 364 | /   kcmp(pid1: pid_t, pid2: pid_t, r#type: c_int, idx1: c_ulong, idx2: c_ulong) /
[INFO] [stdout] 365 | |     { 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],
[INFO] [stdout]     | |________________________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 364 ~   <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] 365 ~     { 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)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:370:3
[INFO] [stdout]     |
[INFO] [stdout] 370 | /   kexec_load(entry: c_ulong, nr_segments: c_ulong, segments: *mut kexec_segment, flags: c_ulong) /
[INFO] [stdout] 371 | |     { entry: c_ulong, segments: Vec<kexec_segment> @ counted_by(raw_args.nr_segments), flags: c_ulong } -> c_long
[INFO] [stdout] 372 | |     ~ [] for [x86_64: 246, aarch64: 104, riscv64: 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] 370 ~   <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] 371 |     { entry: c_ulong, segments: Vec<kexec_segment> @ counted_by(raw_args.nr_segments), flags: c_ulong } -> c_long
[INFO] [stdout] 372 ~     ~ [] for [x86_64: 246, aarch64: 104, riscv64: 104)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:373:3
[INFO] [stdout]     |
[INFO] [stdout] 373 | /   keyctl(option: c_int, arg2: c_ulong, arg3: c_ulong, arg4: c_ulong, arg5: c_ulong) /
[INFO] [stdout] 374 | |     { 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],
[INFO] [stdout]     | |_____________________________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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(keyctl(option: c_int, arg2: c_ulong, arg3: c_ulong, arg4: c_ulong, arg5: c_ulong) /
[INFO] [stdout] 374 ~     { 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)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:375:3
[INFO] [stdout]     |
[INFO] [stdout] 375 |   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],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 375 |   <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)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                  +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:387:3
[INFO] [stdout]     |
[INFO] [stdout] 387 | /   linkat(olddirfd: RawFd, oldpath: *const c_char, newdirfd: RawFd, newpath: *const c_char, flags: c_int) /
[INFO] [stdout] 388 | |     { olddirfd: RawFd, oldpath: PathBuf, newdirfd: RawFd, newpath: PathBuf, flags: c_int } -> c_int
[INFO] [stdout] 389 | |     ~ [Desc, File] for [x86_64: 265, aarch64: 37, riscv64: 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] 387 ~   <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] 388 |     { olddirfd: RawFd, oldpath: PathBuf, newdirfd: RawFd, newpath: PathBuf, flags: c_int } -> c_int
[INFO] [stdout] 389 ~     ~ [Desc, File] for [x86_64: 265, aarch64: 37, riscv64: 37)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:392:3
[INFO] [stdout]     |
[INFO] [stdout] 392 | /   listmount(req: *const __mount_arg, buf: *mut u64, bufsize: size_t, flags: c_uint) /
[INFO] [stdout] 393 | |     { req: __mount_arg, bufsize: size_t, flags: c_uint } -> c_int + { buf: Vec<u64> @ counted_by(raw_args.bufsize) }
[INFO] [stdout] 394 | |      ~ [] for [x86_64: 458, aarch64: 458, riscv64: 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] 392 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(listmount(req: *const __mount_arg, buf: *mut u64, bufsize: size_t, flags: c_uint) /
[INFO] [stdout] 393 |     { req: __mount_arg, bufsize: size_t, flags: c_uint } -> c_int + { buf: Vec<u64> @ counted_by(raw_args.bufsize) }
[INFO] [stdout] 394 ~      ~ [] for [x86_64: 458, aarch64: 458, riscv64: 458)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:399:3
[INFO] [stdout]     |
[INFO] [stdout] 399 | /   listxattrat(dfd: RawFd, pathname: *const c_char, at_flags: c_uint, list: *mut c_char, size: size_t) /
[INFO] [stdout] 400 | |     { dfd: RawFd, pathname: PathBuf, at_flags: c_uint, size: size_t } -> ssize_t + { list: Option<Vec<CString>> }
[INFO] [stdout] 401 | |     ~ [File, Desc] for [x86_64: 465, aarch64: 465, riscv64: 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] 399 ~   <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] 400 |     { dfd: RawFd, pathname: PathBuf, at_flags: c_uint, size: size_t } -> ssize_t + { list: Option<Vec<CString>> }
[INFO] [stdout] 401 ~     ~ [File, Desc] for [x86_64: 465, aarch64: 465, riscv64: 465)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:402:3
[INFO] [stdout]     |
[INFO] [stdout] 402 | /   lookup_dcookie(cookie: u64, buffer: *mut c_char, len: size_t) /
[INFO] [stdout] 403 | |     { cookie: u64, len: size_t } -> c_long + { buffer: PathBuf } ~ [] for [x86_64: 212, aarch64: 18, riscv64: 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] 402 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(lookup_dcookie(cookie: u64, buffer: *mut c_char, len: size_t) /
[INFO] [stdout] 403 ~     { cookie: u64, len: size_t } -> c_long + { buffer: PathBuf } ~ [] for [x86_64: 212, aarch64: 18, riscv64: 18)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:410:3
[INFO] [stdout]     |
[INFO] [stdout] 410 | /   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] 411 | |     -> c_int + { ctx: Vec<u8> } ~ [] for [x86_64: 459, aarch64: 459, riscv64: 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] 410 ~   <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] 411 ~     -> c_int + { ctx: Vec<u8> } ~ [] for [x86_64: 459, aarch64: 459, riscv64: 459)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:412:3
[INFO] [stdout]     |
[INFO] [stdout] 412 | /   lsm_list_modules(ids: *mut u64, size: *mut u32, flags: u32) / { size: InspectResult<u32>, flags: u32 }
[INFO] [stdout] 413 | |     -> c_int + { size: InspectResult<u32>, ids: Vec<u64> @ counted_by_result(size) } ~ [] for [x86_64: 461, aarch64: 461, riscv64: 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] 412 ~   <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] 413 ~     -> c_int + { size: InspectResult<u32>, ids: Vec<u64> @ counted_by_result(size) } ~ [] for [x86_64: 461, aarch64: 461, riscv64: 461)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:414:3
[INFO] [stdout]     |
[INFO] [stdout] 414 | /   lsm_set_self_attr(attr: c_uint, ctx: *const c_void, size: u32, flags: u32) /
[INFO] [stdout] 415 | |     { attr: c_uint, ctx: Vec<u8> @ counted_by(raw_args.size), flags: u32 } -> c_int ~ [] for [x86_64: 460, aarch64: 460, riscv64: 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] 414 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(lsm_set_self_attr(attr: c_uint, ctx: *const c_void, size: u32, flags: u32) /
[INFO] [stdout] 415 ~     { attr: c_uint, ctx: Vec<u8> @ counted_by(raw_args.size), flags: u32 } -> c_int ~ [] for [x86_64: 460, aarch64: 460, riscv64: 460)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:416:3
[INFO] [stdout]     |
[INFO] [stdout] 416 |   lstat(pathname: *const c_char, statbuf: *mut stat) / { pathname: PathBuf } -> c_int + { statbuf: stat } ~ [File, LStat, StatLike] for [x86_64: 6],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 416 |   <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)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                                +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:442:3
[INFO] [stdout]     |
[INFO] [stdout] 442 | /   mkdirat(dirfd: RawFd, pathname: *const c_char, mode: mode_t) / { dirfd: RawFd, pathname: PathBuf, mode: mode_t } -> c_int
[INFO] [stdout] 443 | |     ~ [Desc, File] for [x86_64: 258, aarch64: 34, riscv64: 34],
[INFO] [stdout]     | |_____________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 442 ~   <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] 443 ~     ~ [Desc, File] for [x86_64: 258, aarch64: 34, riscv64: 34)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:445:3
[INFO] [stdout]     |
[INFO] [stdout] 445 | /   mknodat(dirfd: RawFd, pathname: *const c_char, mode: mode_t, dev: dev_t) /
[INFO] [stdout] 446 | |     { dirfd: RawFd, pathname: PathBuf, mode: mode_t, dev: dev_t } -> c_int ~ [Desc, File] for [x86_64: 259, aarch64: 33, riscv64: 33],
[INFO] [stdout]     | |____________________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 445 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(mknodat(dirfd: RawFd, pathname: *const c_char, mode: mode_t, dev: dev_t) /
[INFO] [stdout] 446 ~     { dirfd: RawFd, pathname: PathBuf, mode: mode_t, dev: dev_t } -> c_int ~ [Desc, File] for [x86_64: 259, aarch64: 33, riscv64: 33)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:455:3
[INFO] [stdout]     |
[INFO] [stdout] 455 | /   modify_ldt(func: c_int, ptr: *mut c_void, bytecount: c_ulong) / { func: c_int, ptr: AddressType, bytecount: c_ulong } -> c_int
[INFO] [stdout] 456 | |     ~ [] 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] 455 ~   <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] 456 ~     ~ [] for [x86_64: 154)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:460:3
[INFO] [stdout]     |
[INFO] [stdout] 460 | /   mount_setattr(dirfd: RawFd, pathname: *const c_char, flags: c_uint, uattr: *mut c_void, r#usize: size_t) /
[INFO] [stdout] 461 | |     { dirfd: RawFd, pathname: PathBuf, flags: c_uint, uattr: Arc<mount_attr> @ sized_by(raw_args.r#usize) } -> c_int
[INFO] [stdout] 462 | |     ~ [Desc, File] for [x86_64: 442, aarch64: 442, riscv64: 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] 460 ~   <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] 461 |     { dirfd: RawFd, pathname: PathBuf, flags: c_uint, uattr: Arc<mount_attr> @ sized_by(raw_args.r#usize) } -> c_int
[INFO] [stdout] 462 ~     ~ [Desc, File] for [x86_64: 442, aarch64: 442, riscv64: 442)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:463:3
[INFO] [stdout]     |
[INFO] [stdout] 463 | /   move_mount(from_dfd: RawFd, from_path: *const c_char, to_dfd: RawFd, to_path: *const c_char, ms_flags: c_uint) /
[INFO] [stdout] 464 | |     { from_dfd: RawFd, from_path: PathBuf, to_dfd: RawFd, to_path: PathBuf, ms_flags: c_uint } -> c_int
[INFO] [stdout] 465 | |     ~ [Desc, File] for [x86_64: 429, aarch64: 429, riscv64: 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] 463 ~   <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] 464 |     { from_dfd: RawFd, from_path: PathBuf, to_dfd: RawFd, to_path: PathBuf, ms_flags: c_uint } -> c_int
[INFO] [stdout] 465 ~     ~ [Desc, File] for [x86_64: 429, aarch64: 429, riscv64: 429)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:491:3
[INFO] [stdout]     |
[INFO] [stdout] 491 |   mq_unlink(name: *const c_char) / { name: CString } -> c_int ~ [] for [x86_64: 241, aarch64: 181, riscv64: 181],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 491 |   <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)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                             +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:498:3
[INFO] [stdout]     |
[INFO] [stdout] 498 | /   msgctl(msqid: c_int, cmd: c_int, buf: *mut msqid_ds) / { msqid: c_int, cmd: c_int } -> c_int + { buf: msqid_ds }
[INFO] [stdout] 499 | |     ~ [] for [x86_64: 71, aarch64: 187, riscv64: 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] 498 ~   <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] 499 ~     ~ [] for [x86_64: 71, aarch64: 187, riscv64: 187)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:500:3
[INFO] [stdout]     |
[INFO] [stdout] 500 |   msgget(key: key_t, msgflg: c_int) / { key: key_t, msgflg: c_int } -> c_int ~ [] for [x86_64: 68, aarch64: 186, riscv64: 186],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 500 |   <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)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:501:3
[INFO] [stdout]     |
[INFO] [stdout] 501 | /   msgrcv(msqid: c_int, msgp: *mut c_void, msgsz: size_t, msgtyp: c_long, msgflg: c_int) /
[INFO] [stdout] 502 | |     { 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] 503 | |     ~ [] for [x86_64: 70, aarch64: 188, riscv64: 188],
[INFO] [stdout]     | |____________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 501 ~   <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] 502 |     { 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] 503 ~     ~ [] for [x86_64: 70, aarch64: 188, riscv64: 188)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:504:3
[INFO] [stdout]     |
[INFO] [stdout] 504 | /   msgsnd(msqid: c_int, msgp: *const c_void, msgsz: size_t, msgflg: c_int) /
[INFO] [stdout] 505 | |     { 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],
[INFO] [stdout]     | |__________________________________________________________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 504 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(msgsnd(msqid: c_int, msgp: *const c_void, msgsz: size_t, msgflg: c_int) /
[INFO] [stdout] 505 ~     { 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)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:512:3
[INFO] [stdout]     |
[INFO] [stdout] 512 | /   name_to_handle_at(dirfd: RawFd, pathname: *const c_char, handle: *mut c_void, mount_id: *mut c_int, flags: c_int) /
[INFO] [stdout] 513 | |     { dirfd: RawFd, pathname: PathBuf, flags: c_int } -> c_int +
[INFO] [stdout] 514 | |     { handle: Arc<file_handle> @ sized_by_result(<InspectResult<c_uint> as InspectFromPid>::inspect_from(inspectee_pid, raw_args....
[INFO] [stdout] 515 | |       mount_id: InspectResult<c_int> }
[INFO] [stdout] 516 | |     ~ [Desc, File] for [x86_64: 303, aarch64: 264, riscv64: 264],
[INFO] [stdout]     | |_______________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 512 ~   <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] 513 |     { dirfd: RawFd, pathname: PathBuf, flags: c_int } -> c_int +
[INFO] [stdout] 514 |     { handle: Arc<file_handle> @ sized_by_result(<InspectResult<c_uint> as InspectFromPid>::inspect_from(inspectee_pid, raw_args.handle as AddressType)),
[INFO] [stdout] 515 |       mount_id: InspectResult<c_int> }
[INFO] [stdout] 516 ~     ~ [Desc, File] for [x86_64: 303, aarch64: 264, riscv64: 264)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:519:3
[INFO] [stdout]     |
[INFO] [stdout] 519 | /   newfstatat(dirfd: RawFd, pathname: *const c_char, statbuf: *mut stat, flags: c_int) /
[INFO] [stdout] 520 | |     { dirfd: RawFd, pathname: PathBuf, flags: c_int } -> c_int + { statbuf: stat }
[INFO] [stdout] 521 | |     ~ [Desc, File, FStat, StatLike] for [x86_64: 262, aarch64: 79, riscv64: 79],
[INFO] [stdout]     | |______________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 519 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(newfstatat(dirfd: RawFd, pathname: *const c_char, statbuf: *mut stat, flags: c_int) /
[INFO] [stdout] 520 |     { dirfd: RawFd, pathname: PathBuf, flags: c_int } -> c_int + { statbuf: stat }
[INFO] [stdout] 521 ~     ~ [Desc, File, FStat, StatLike] for [x86_64: 262, aarch64: 79, riscv64: 79)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:530:3
[INFO] [stdout]     |
[INFO] [stdout] 530 | /   open(pathname: *const c_char, flags: c_int, mode: mode_t) / { pathname: PathBuf, flags: c_int, mode: mode_t } -> RawFd
[INFO] [stdout] 531 | |     ~ [Desc, File] for [x86_64: 2, aarch64: 56, riscv64: 56],
[INFO] [stdout]     | |___________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 530 ~   <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] 531 ~     ~ [Desc, File] for [x86_64: 2, aarch64: 56, riscv64: 56)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:537:3
[INFO] [stdout]     |
[INFO] [stdout] 537 | /   open_tree(dirfd: RawFd, path: *const c_char, flags: c_uint) / { dirfd: RawFd, path: PathBuf, flags: c_uint } -> c_int
[INFO] [stdout] 538 | |     ~ [Desc, File] for [x86_64: 428, aarch64: 428, riscv64: 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] 537 ~   <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] 538 ~     ~ [Desc, File] for [x86_64: 428, aarch64: 428, riscv64: 428)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:539:3
[INFO] [stdout]     |
[INFO] [stdout] 539 | /   open_tree_attr(dfd: RawFd, filename: *const c_char, flags: c_uint, uattr: *mut c_void, r#usize: size_t) /
[INFO] [stdout] 540 | |     { dfd: RawFd, filename: PathBuf, flags: c_uint, uattr: Arc<mount_attr> @ sized_by(raw_args.r#usize) } -> c_int
[INFO] [stdout] 541 | |     ~ [Desc, File] for [x86_64: 467, aarch64: 467, riscv64: 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] 539 ~   <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] 540 |     { dfd: RawFd, filename: PathBuf, flags: c_uint, uattr: Arc<mount_attr> @ sized_by(raw_args.r#usize) } -> c_int
[INFO] [stdout] 541 ~     ~ [Desc, File] for [x86_64: 467, aarch64: 467, riscv64: 467)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:542:3
[INFO] [stdout]     |
[INFO] [stdout] 542 | /   openat(dirfd: RawFd, pathname: *const c_char, flags: c_int, mode: mode_t) /
[INFO] [stdout] 543 | |     { dirfd: RawFd, pathname: PathBuf, flags: c_int, mode: mode_t } -> RawFd ~ [Desc, File] for [x86_64: 257, aarch64: 56, riscv64: 56],
[INFO] [stdout]     | |______________________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 542 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(openat(dirfd: RawFd, pathname: *const c_char, flags: c_int, mode: mode_t) /
[INFO] [stdout] 543 ~     { dirfd: RawFd, pathname: PathBuf, flags: c_int, mode: mode_t } -> RawFd ~ [Desc, File] for [x86_64: 257, aarch64: 56, riscv64: 56)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:544:3
[INFO] [stdout]     |
[INFO] [stdout] 544 | /   openat2(dirfd: RawFd, pathname: *const c_char, how: *mut open_how, size: size_t) /
[INFO] [stdout] 545 | |     { dirfd: RawFd, pathname: PathBuf, how: open_how, size: size_t } -> c_int ~ [Desc, File] for [x86_64: 437, aarch64: 437, riscv64: 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] 544 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(openat2(dirfd: RawFd, pathname: *const c_char, how: *mut open_how, size: size_t) /
[INFO] [stdout] 545 ~     { dirfd: RawFd, pathname: PathBuf, how: open_how, size: size_t } -> c_int ~ [Desc, File] for [x86_64: 437, aarch64: 437, riscv64: 437)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:557:3
[INFO] [stdout]     |
[INFO] [stdout] 557 |   personality(persona: c_ulong) / { persona: c_ulong } -> c_int ~ [] for [x86_64: 135, aarch64: 92, riscv64: 92],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 557 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(personality(persona: c_ulong) / { persona: c_ulong } -> c_int ~ [] for [x86_64: 135, aarch64: 92, riscv64: 92)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                             +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:561:3
[INFO] [stdout]     |
[INFO] [stdout] 561 | /   pidfd_send_signal(pidfd: RawFd, sig: c_int, info: *mut siginfo_t, flags: c_uint) /
[INFO] [stdout] 562 | |     { pidfd: RawFd, sig: c_int, info: Option<siginfo_t>, flags: c_uint } -> c_int
[INFO] [stdout] 563 | |     ~ [Desc, Signal, Process] for [x86_64: 424, aarch64: 424, riscv64: 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] 561 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(pidfd_send_signal(pidfd: RawFd, sig: c_int, info: *mut siginfo_t, flags: c_uint) /
[INFO] [stdout] 562 |     { pidfd: RawFd, sig: c_int, info: Option<siginfo_t>, flags: c_uint } -> c_int
[INFO] [stdout] 563 ~     ~ [Desc, Signal, Process] for [x86_64: 424, aarch64: 424, riscv64: 424)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:568:3
[INFO] [stdout]     |
[INFO] [stdout] 568 |   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],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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(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)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                                      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:569:3
[INFO] [stdout]     |
[INFO] [stdout] 569 |   pkey_free(pkey: c_int) / { pkey: c_int } -> c_int ~ [] for [x86_64: 331, aarch64: 290, riscv64: 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] 569 |   <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)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                   +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:589:3
[INFO] [stdout]     |
[INFO] [stdout] 589 | /   prlimit64(pid: pid_t, resource: c_int, new_limit: *const rlimit64, old_limit: *mut rlimit64) /
[INFO] [stdout] 590 | |     { pid: pid_t, resource: c_int, new_limit: Option<rlimit64>, old_limit: Option<rlimit64> } -> c_int + { old_limit: Option<rlim...
[INFO] [stdout] 591 | |     ~ [] for [x86_64: 302, aarch64: 261, riscv64: 261],
[INFO] [stdout]     | |_____________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 589 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(prlimit64(pid: pid_t, resource: c_int, new_limit: *const rlimit64, old_limit: *mut rlimit64) /
[INFO] [stdout] 590 |     { pid: pid_t, resource: c_int, new_limit: Option<rlimit64>, old_limit: Option<rlimit64> } -> c_int + { old_limit: Option<rlimit64> }
[INFO] [stdout] 591 ~     ~ [] for [x86_64: 302, aarch64: 261, riscv64: 261)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:596:3
[INFO] [stdout]     |
[INFO] [stdout] 596 | /   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] 597 | |     { pid: pid_t, local_iov: Vec<iovec> @ counted_by(raw_args.liovcnt), remote_iov: Vec<iovec> @ counted_by(raw_args.riovcnt), fl...
[INFO] [stdout] 598 | |     -> ssize_t ~ [] for [x86_64: 310, aarch64: 270, riscv64: 270],
[INFO] [stdout]     | |________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 596 ~   <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] 597 |     { 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] 598 ~     -> ssize_t ~ [] for [x86_64: 310, aarch64: 270, riscv64: 270)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:599:3
[INFO] [stdout]     |
[INFO] [stdout] 599 | /   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] 600 | |     { pid: pid_t, local_iov: Vec<iovec> @ counted_by(raw_args.liovcnt), remote_iov: Vec<iovec> @ counted_by(raw_args.riovcnt), fl...
[INFO] [stdout] 601 | |     -> ssize_t ~ [] for [x86_64: 311, aarch64: 271, riscv64: 271],
[INFO] [stdout]     | |________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 599 ~   <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] 600 |     { 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] 601 ~     -> ssize_t ~ [] for [x86_64: 311, aarch64: 271, riscv64: 271)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:608:3
[INFO] [stdout]     |
[INFO] [stdout] 608 | /   ptrace(request: c_int, pid: pid_t, addr: *mut c_void, data: *mut c_void) / { } -> c_long
[INFO] [stdout] 609 | |     ~ [] for [x86_64: 101, aarch64: 117, riscv64: 117],
[INFO] [stdout]     | |_____________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 608 ~   <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] 609 ~     ~ [] for [x86_64: 101, aarch64: 117, riscv64: 117)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:627:3
[INFO] [stdout]     |
[INFO] [stdout] 627 | /   readlinkat(dirfd: RawFd, pathname: *const c_char, buf: *mut c_char, bufsiz: size_t) /
[INFO] [stdout] 628 | |     { dirfd: RawFd, pathname: PathBuf, bufsiz: size_t } -> ssize_t + { buf: Vec<u8> @ counted_by(syscall_result) }
[INFO] [stdout] 629 | |     ~ [Desc, File] for [x86_64: 267, aarch64: 78, riscv64: 78],
[INFO] [stdout]     | |_____________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 627 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(readlinkat(dirfd: RawFd, pathname: *const c_char, buf: *mut c_char, bufsiz: size_t) /
[INFO] [stdout] 628 |     { dirfd: RawFd, pathname: PathBuf, bufsiz: size_t } -> ssize_t + { buf: Vec<u8> @ counted_by(syscall_result) }
[INFO] [stdout] 629 ~     ~ [Desc, File] for [x86_64: 267, aarch64: 78, riscv64: 78)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:632:3
[INFO] [stdout]     |
[INFO] [stdout] 632 | /   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] 633 | |     ~ [] for [x86_64: 169, aarch64: 142, riscv64: 142],
[INFO] [stdout]     | |_____________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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(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] 633 ~     ~ [] for [x86_64: 169, aarch64: 142, riscv64: 142)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:649:3
[INFO] [stdout]     |
[INFO] [stdout] 649 | /   removexattrat(dfd: RawFd, pathname: *const c_char, at_flags: c_uint, name: *const c_char) /
[INFO] [stdout] 650 | |     { dfd: RawFd, pathname: PathBuf, at_flags: c_uint, name: CString } -> c_int
[INFO] [stdout] 651 | |     ~ [File, Desc] for [x86_64: 466, aarch64: 466, riscv64: 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] 649 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(removexattrat(dfd: RawFd, pathname: *const c_char, at_flags: c_uint, name: *const c_char) /
[INFO] [stdout] 650 |     { dfd: RawFd, pathname: PathBuf, at_flags: c_uint, name: CString } -> c_int
[INFO] [stdout] 651 ~     ~ [File, Desc] for [x86_64: 466, aarch64: 466, riscv64: 466)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:654:3
[INFO] [stdout]     |
[INFO] [stdout] 654 | /   renameat(olddirfd: RawFd, oldpath: *const c_char, newdirfd: RawFd, newpath: *const c_char) /
[INFO] [stdout] 655 | |     { olddirfd: RawFd, oldpath: PathBuf, newdirfd: RawFd, newpath: PathBuf } -> c_int
[INFO] [stdout] 656 | |     ~ [Desc, File] for [x86_64: 264, aarch64: 38],
[INFO] [stdout]     | |________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 654 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(renameat(olddirfd: RawFd, oldpath: *const c_char, newdirfd: RawFd, newpath: *const c_char) /
[INFO] [stdout] 655 |     { olddirfd: RawFd, oldpath: PathBuf, newdirfd: RawFd, newpath: PathBuf } -> c_int
[INFO] [stdout] 656 ~     ~ [Desc, File] for [x86_64: 264, aarch64: 38)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:657:3
[INFO] [stdout]     |
[INFO] [stdout] 657 | /   renameat2(olddirfd: RawFd, oldpath: *const c_char, newdirfd: RawFd, newpath: *const c_char, flags: c_uint) /
[INFO] [stdout] 658 | |     { olddirfd: RawFd, oldpath: PathBuf, newdirfd: RawFd, newpath: PathBuf, flags: c_uint } -> c_int
[INFO] [stdout] 659 | |     ~ [Desc, File] for [x86_64: 316, aarch64: 276, riscv64: 276],
[INFO] [stdout]     | |_______________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 657 ~   <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] 658 |     { olddirfd: RawFd, oldpath: PathBuf, newdirfd: RawFd, newpath: PathBuf, flags: c_uint } -> c_int
[INFO] [stdout] 659 ~     ~ [Desc, File] for [x86_64: 316, aarch64: 276, riscv64: 276)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:660:3
[INFO] [stdout]     |
[INFO] [stdout] 660 | /   request_key(r#type: *const c_char, description: *const c_char, callout_info: *const c_char, dest_keyring: key_serial_t) /
[INFO] [stdout] 661 | |     { r#type: CString, description: CString, callout_info: Option<CString>, dest_keyring: key_serial_t } -> key_serial_t
[INFO] [stdout] 662 | |     ~ [] for [x86_64: 249, aarch64: 218, riscv64: 218],
[INFO] [stdout]     | |_____________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 660 ~   <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] 661 |     { r#type: CString, description: CString, callout_info: Option<CString>, dest_keyring: key_serial_t } -> key_serial_t
[INFO] [stdout] 662 ~     ~ [] for [x86_64: 249, aarch64: 218, riscv64: 218)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:663:3
[INFO] [stdout]     |
[INFO] [stdout] 663 |   restart_syscall() / {} -> c_long ~ [] for [x86_64: 219, aarch64: 128, riscv64: 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] 663 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(restart_syscall() / {} -> c_long ~ [] for [x86_64: 219, aarch64: 128, riscv64: 128)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                  +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:674:3
[INFO] [stdout]     |
[INFO] [stdout] 674 | /   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] 675 | |     ~ [] for [x86_64: 334, aarch64: 293, riscv64: 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] 674 ~   <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] 675 ~     ~ [] for [x86_64: 334, aarch64: 293, riscv64: 293)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:684:3
[INFO] [stdout]     |
[INFO] [stdout] 684 | /   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] 685 | |     ~ [Signal, Process] for [x86_64: 129, aarch64: 138, riscv64: 138],
[INFO] [stdout]     | |____________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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(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] 685 ~     ~ [Signal, Process] for [x86_64: 129, aarch64: 138, riscv64: 138)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:694:3
[INFO] [stdout]     |
[INFO] [stdout] 694 | /   rt_tgsigqueueinfo(tgid: pid_t, pid: pid_t, sig: c_int, info: *mut siginfo_t) /
[INFO] [stdout] 695 | |     { tgid: pid_t, pid: pid_t, sig: c_int, info: siginfo_t } -> c_int ~ [Signal, Process] for [x86_64: 297, aarch64: 240, riscv64: 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] 694 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(rt_tgsigqueueinfo(tgid: pid_t, pid: pid_t, sig: c_int, info: *mut siginfo_t) /
[INFO] [stdout] 695 ~     { tgid: pid_t, pid: pid_t, sig: c_int, info: siginfo_t } -> c_int ~ [Signal, Process] for [x86_64: 297, aarch64: 240, riscv64: 240)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:698:3
[INFO] [stdout]     |
[INFO] [stdout] 698 |   sched_get_priority_max(policy: c_int) / { policy: c_int } -> c_int ~ [] for [x86_64: 146, aarch64: 125, riscv64: 125],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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(sched_get_priority_max(policy: c_int) / { policy: c_int } -> c_int ~ [] for [x86_64: 146, aarch64: 125, riscv64: 125)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:699:3
[INFO] [stdout]     |
[INFO] [stdout] 699 |   sched_get_priority_min(policy: c_int) / { policy: c_int } -> c_int ~ [] for [x86_64: 147, aarch64: 126, riscv64: 126],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 699 |   <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)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:701:3
[INFO] [stdout]     |
[INFO] [stdout] 701 | /   sched_getaffinity(pid: pid_t, cpusetsize: size_t, mask: *mut c_ulong) /
[INFO] [stdout] 702 | |     { pid: pid_t, cpusetsize: size_t } -> c_int + { mask: Vec<u8> @ counted_by(syscall_result) }
[INFO] [stdout] 703 | |     ~ [] for [x86_64: 204, aarch64: 123, riscv64: 123],
[INFO] [stdout]     | |_____________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 701 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(sched_getaffinity(pid: pid_t, cpusetsize: size_t, mask: *mut c_ulong) /
[INFO] [stdout] 702 |     { pid: pid_t, cpusetsize: size_t } -> c_int + { mask: Vec<u8> @ counted_by(syscall_result) }
[INFO] [stdout] 703 ~     ~ [] for [x86_64: 204, aarch64: 123, riscv64: 123)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:704:3
[INFO] [stdout]     |
[INFO] [stdout] 704 | /   sched_getattr(pid: pid_t, attr: *mut sched_attr, size: c_uint, flags: c_uint) /
[INFO] [stdout] 705 | |     { pid: pid_t, size: c_uint, flags: c_uint } -> c_int + { attr: sched_attr }
[INFO] [stdout] 706 | |     ~ [] for [x86_64: 315, aarch64: 275, riscv64: 275],
[INFO] [stdout]     | |_____________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 704 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(sched_getattr(pid: pid_t, attr: *mut sched_attr, size: c_uint, flags: c_uint) /
[INFO] [stdout] 705 |     { pid: pid_t, size: c_uint, flags: c_uint } -> c_int + { attr: sched_attr }
[INFO] [stdout] 706 ~     ~ [] for [x86_64: 315, aarch64: 275, riscv64: 275)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:707:3
[INFO] [stdout]     |
[INFO] [stdout] 707 | /   sched_getparam(pid: pid_t, param: *mut sched_param) / { pid: pid_t } -> c_int + { param: sched_param }
[INFO] [stdout] 708 | |     ~ [] for [x86_64: 143, aarch64: 121, riscv64: 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] 707 ~   <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] 708 ~     ~ [] for [x86_64: 143, aarch64: 121, riscv64: 121)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:709:3
[INFO] [stdout]     |
[INFO] [stdout] 709 |   sched_getscheduler(pid: pid_t) / { pid: pid_t } -> c_int ~ [] for [x86_64: 145, aarch64: 120, riscv64: 120],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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(sched_getscheduler(pid: pid_t) / { pid: pid_t } -> c_int ~ [] for [x86_64: 145, aarch64: 120, riscv64: 120)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                          +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:710:3
[INFO] [stdout]     |
[INFO] [stdout] 710 | /   sched_rr_get_interval(pid: pid_t, tp: *mut timespec) / { pid: pid_t } -> c_int + { tp: timespec }
[INFO] [stdout] 711 | |     ~ [] for [x86_64: 148, aarch64: 127, riscv64: 127],
[INFO] [stdout]     | |_____________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 710 ~   <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] 711 ~     ~ [] for [x86_64: 148, aarch64: 127, riscv64: 127)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:714:3
[INFO] [stdout]     |
[INFO] [stdout] 714 | /   sched_setaffinity(pid: pid_t, cpusetsize: size_t, mask: *const c_ulong) /
[INFO] [stdout] 715 | |     { pid: pid_t, cpusetsize: size_t, mask: Vec<u8> @ counted_by(cpusetsize) } -> c_int
[INFO] [stdout] 716 | |     ~ [] for [x86_64: 203, aarch64: 122, riscv64: 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] 714 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(sched_setaffinity(pid: pid_t, cpusetsize: size_t, mask: *const c_ulong) /
[INFO] [stdout] 715 |     { pid: pid_t, cpusetsize: size_t, mask: Vec<u8> @ counted_by(cpusetsize) } -> c_int
[INFO] [stdout] 716 ~     ~ [] for [x86_64: 203, aarch64: 122, riscv64: 122)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:718:3
[INFO] [stdout]     |
[INFO] [stdout] 718 | /   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] 719 | |     ~ [] for [x86_64: 314, aarch64: 274, riscv64: 274],
[INFO] [stdout]     | |_____________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 718 ~   <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] 719 ~     ~ [] for [x86_64: 314, aarch64: 274, riscv64: 274)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:720:3
[INFO] [stdout]     |
[INFO] [stdout] 720 | /   sched_setparam(pid: pid_t, param: *const sched_param) / { pid: pid_t, param: sched_param } -> c_int
[INFO] [stdout] 721 | |     ~ [] for [x86_64: 142, aarch64: 118, riscv64: 118],
[INFO] [stdout]     | |_____________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 720 ~   <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] 721 ~     ~ [] for [x86_64: 142, aarch64: 118, riscv64: 118)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:722:3
[INFO] [stdout]     |
[INFO] [stdout] 722 | /   sched_setscheduler(pid: pid_t, policy: c_int, param: *const sched_param) /
[INFO] [stdout] 723 | |     { pid: pid_t, policy: c_int, param: sched_param } -> c_int
[INFO] [stdout] 724 | |     ~ [] for [x86_64: 144, aarch64: 119, riscv64: 119],
[INFO] [stdout]     | |_____________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 722 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(sched_setscheduler(pid: pid_t, policy: c_int, param: *const sched_param) /
[INFO] [stdout] 723 |     { pid: pid_t, policy: c_int, param: sched_param } -> c_int
[INFO] [stdout] 724 ~     ~ [] for [x86_64: 144, aarch64: 119, riscv64: 119)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:725:3
[INFO] [stdout]     |
[INFO] [stdout] 725 |   sched_yield() / {} -> c_int ~ [] for [x86_64: 24, aarch64: 124, riscv64: 124],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 725 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(sched_yield() / {} -> c_int ~ [] for [x86_64: 24, aarch64: 124, riscv64: 124)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                            +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:727:3
[INFO] [stdout]     |
[INFO] [stdout] 727 | /   seccomp(operation: c_int, flags: c_uint, args: *mut c_void) / { operation: c_int, flags: c_uint } -> c_int
[INFO] [stdout] 728 | |     ~ [] for [x86_64: 317, aarch64: 277, riscv64: 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] 727 ~   <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] 728 ~     ~ [] for [x86_64: 317, aarch64: 277, riscv64: 277)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:745:3
[INFO] [stdout]     |
[INFO] [stdout] 745 | /   sendfile(out_fd: RawFd, in_fd: RawFd, offset: *mut off_t, count: size_t) /
[INFO] [stdout] 746 | |     { out_fd: RawFd, in_fd: RawFd, offset: off_t, count: size_t } -> ssize_t ~ [Desc, Network] for [x86_64: 40, aarch64: 71, riscv64: 71],
[INFO] [stdout]     | |________________________________________________________________________________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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(sendfile(out_fd: RawFd, in_fd: RawFd, offset: *mut off_t, count: size_t) /
[INFO] [stdout] 746 ~     { out_fd: RawFd, in_fd: RawFd, offset: off_t, count: size_t } -> ssize_t ~ [Desc, Network] for [x86_64: 40, aarch64: 71, riscv64: 71)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:764:3
[INFO] [stdout]     |
[INFO] [stdout] 764 | /   set_robust_list(head: *mut robust_list_head, len: size_t) / { head: AddressType, len: size_t } -> c_long
[INFO] [stdout] 765 | |     ~ [] for [x86_64: 273, aarch64: 99, riscv64: 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] 764 ~   <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] 765 ~     ~ [] for [x86_64: 273, aarch64: 99, riscv64: 99)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:766:3
[INFO] [stdout]     |
[INFO] [stdout] 766 |   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] 766 |   <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>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:767:3
[INFO] [stdout]     |
[INFO] [stdout] 767 |   set_tid_address(tidptr: *mut c_int) / { tidptr: AddressType } -> pid_t ~ [] for [x86_64: 218, aarch64: 96, riscv64: 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] 767 |   <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)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:769:3
[INFO] [stdout]     |
[INFO] [stdout] 769 |   setdomainname(name: *const c_char, len: size_t) / { name: CString } -> c_int ~ [] for [x86_64: 171, aarch64: 162, riscv64: 162],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 769 |   <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)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                              +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:781:3
[INFO] [stdout]     |
[INFO] [stdout] 781 | /   sethostname(name: *const c_char, len: size_t) / { name: CString, len: size_t } -> c_int
[INFO] [stdout] 782 | |     ~ [] for [x86_64: 170, aarch64: 161, riscv64: 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] 781 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(sethostname(name: *const c_char, len: size_t) / { name: CString, len: size_t } -> c_int
[INFO] [stdout] 782 ~     ~ [] for [x86_64: 170, aarch64: 161, riscv64: 161)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:783:3
[INFO] [stdout]     |
[INFO] [stdout] 783 | /   setitimer(which: c_int, new_value: *const itimerval, old_value: *mut itimerval) /
[INFO] [stdout] 784 | |     { which: c_int, new_value: itimerval, old_value: Option<itimerval> } -> c_int
[INFO] [stdout] 785 | |     ~ [] for [x86_64: 38, aarch64: 103, riscv64: 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] 783 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(setitimer(which: c_int, new_value: *const itimerval, old_value: *mut itimerval) /
[INFO] [stdout] 784 |     { which: c_int, new_value: itimerval, old_value: Option<itimerval> } -> c_int
[INFO] [stdout] 785 ~     ~ [] for [x86_64: 38, aarch64: 103, riscv64: 103)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:787:3
[INFO] [stdout]     |
[INFO] [stdout] 787 |   setpgid(pid: pid_t, pgid: pid_t) / { pid: pid_t, pgid: pid_t } -> c_int ~ [] for [x86_64: 109, aarch64: 154, riscv64: 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] 787 |   <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)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                         +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:789:3
[INFO] [stdout]     |
[INFO] [stdout] 789 | /   setpriority(which: c_int, who: id_t, prio: c_int) / { which: c_int, who: id_t, prio: c_int } -> c_int
[INFO] [stdout] 790 | |     ~ [] for [x86_64: 141, aarch64: 140, riscv64: 140],
[INFO] [stdout]     | |_____________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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(setpriority(which: c_int, who: id_t, prio: c_int) / { which: c_int, who: id_t, prio: c_int } -> c_int
[INFO] [stdout] 790 ~     ~ [] for [x86_64: 141, aarch64: 140, riscv64: 140)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:801:3
[INFO] [stdout]     |
[INFO] [stdout] 801 | /   setrlimit(resource: c_int, rlim: *const rlimit) / { resource: c_int, rlim: rlimit } -> c_int
[INFO] [stdout] 802 | |     ~ [] for [x86_64: 160, aarch64: 164, riscv64: 164],
[INFO] [stdout]     | |_____________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 801 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(setrlimit(resource: c_int, rlim: *const rlimit) / { resource: c_int, rlim: rlimit } -> c_int
[INFO] [stdout] 802 ~     ~ [] for [x86_64: 160, aarch64: 164, riscv64: 164)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:803:3
[INFO] [stdout]     |
[INFO] [stdout] 803 |   setsid() / {} -> pid_t ~ [] for [x86_64: 112, aarch64: 157, riscv64: 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] 803 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(setsid() / {} -> pid_t ~ [] for [x86_64: 112, aarch64: 157, riscv64: 157)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                        +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:814:3
[INFO] [stdout]     |
[INFO] [stdout] 814 | /   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] 815 | |     { dfd: RawFd, pathname: PathBuf, at_flags: c_uint, name: CString, uargs: Arc<xattr_args> @ sized_by(raw_args.r#usize) } -> c_int
[INFO] [stdout] 816 | |     ~ [File, Desc] for [x86_64: 463, aarch64: 463, riscv64: 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] 814 ~   <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] 815 |     { dfd: RawFd, pathname: PathBuf, at_flags: c_uint, name: CString, uargs: Arc<xattr_args> @ sized_by(raw_args.r#usize) } -> c_int
[INFO] [stdout] 816 ~     ~ [File, Desc] for [x86_64: 463, aarch64: 463, riscv64: 463)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:818:3
[INFO] [stdout]     |
[INFO] [stdout] 818 | /   shmat(shmid: c_int, shmaddr: *const c_void, shmflg: c_int) / { shmid: c_int, shmaddr: AddressType, shmflg: c_int } -> AddressType
[INFO] [stdout] 819 | |     ~ [IPC, Memory] for [x86_64: 30, aarch64: 196, riscv64: 196],
[INFO] [stdout]     | |_______________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 818 ~   <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] 819 ~     ~ [IPC, Memory] for [x86_64: 30, aarch64: 196, riscv64: 196)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:822:3
[INFO] [stdout]     |
[INFO] [stdout] 822 |   shmdt(shmaddr: *const c_void) / { shmaddr: AddressType } -> c_int ~ [IPC, Memory] for [x86_64: 67, aarch64: 197, riscv64: 197],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 822 |   <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)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                             +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:830:3
[INFO] [stdout]     |
[INFO] [stdout] 830 | /   signalfd(fd: RawFd, mask: *const sigset_t, size: size_t) / { fd: RawFd, mask: sigset_t, size: size_t } -> c_int
[INFO] [stdout] 831 | |     ~ [Desc, Signal] for [x86_64: 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] 830 ~   <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] 831 ~     ~ [Desc, Signal] for [x86_64: 282)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:832:3
[INFO] [stdout]     |
[INFO] [stdout] 832 | /   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] 833 | |     ~ [Desc, Signal] for [x86_64: 289, aarch64: 74, riscv64: 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] 832 ~   <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] 833 ~     ~ [Desc, Signal] for [x86_64: 289, aarch64: 74, riscv64: 74)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:850:3
[INFO] [stdout]     |
[INFO] [stdout] 850 | /   stat(pathname: *const c_char, statbuf: *mut stat) / { pathname: PathBuf } -> c_int + { statbuf: stat }
[INFO] [stdout] 851 | |     ~ [File, Stat, StatLike] for [x86_64: 4],
[INFO] [stdout]     | |___________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 850 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(stat(pathname: *const c_char, statbuf: *mut stat) / { pathname: PathBuf } -> c_int + { statbuf: stat }
[INFO] [stdout] 851 ~     ~ [File, Stat, StatLike] for [x86_64: 4)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:853:3
[INFO] [stdout]     |
[INFO] [stdout] 853 | /   statfs(path: *const c_char, buf: *mut statfs) / { path: PathBuf } -> c_int + { buf: statfs }
[INFO] [stdout] 854 | |     ~ [File, StatFs, StatFsLike] for [x86_64: 137, aarch64: 43, riscv64: 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] 853 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(statfs(path: *const c_char, buf: *mut statfs) / { path: PathBuf } -> c_int + { buf: statfs }
[INFO] [stdout] 854 ~     ~ [File, StatFs, StatFsLike] for [x86_64: 137, aarch64: 43, riscv64: 43)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:857:3
[INFO] [stdout]     |
[INFO] [stdout] 857 | /   statmount(req: *const mnt_id_req, buf: *mut c_void, bufsize: size_t, flags: c_uint) /
[INFO] [stdout] 858 | |     { req: mnt_id_req, bufsize: size_t, flags: c_uint } -> c_int + { buf: Arc<statmount> @ sized_by(raw_args.bufsize) }
[INFO] [stdout] 859 | |     ~ [] for [x86_64: 457, aarch64: 457, riscv64: 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] 857 ~   <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] 858 |     { req: mnt_id_req, bufsize: size_t, flags: c_uint } -> c_int + { buf: Arc<statmount> @ sized_by(raw_args.bufsize) }
[INFO] [stdout] 859 ~     ~ [] for [x86_64: 457, aarch64: 457, riscv64: 457)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:860:3
[INFO] [stdout]     |
[INFO] [stdout] 860 | /   statx(dirfd: RawFd, pathname: *const c_char, flags: c_int, mask: c_uint, statxbuf: *mut statx) /
[INFO] [stdout] 861 | |     { dirfd: RawFd, pathname: PathBuf, flags: c_int, mask: c_uint } -> c_int + { statxbuf: statx }
[INFO] [stdout] 862 | |     ~ [Desc, File, FStat, StatLike] for [x86_64: 332, aarch64: 291, riscv64: 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] 860 ~   <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] 861 |     { dirfd: RawFd, pathname: PathBuf, flags: c_int, mask: c_uint } -> c_int + { statxbuf: statx }
[INFO] [stdout] 862 ~     ~ [Desc, File, FStat, StatLike] for [x86_64: 332, aarch64: 291, riscv64: 291)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:872:3
[INFO] [stdout]     |
[INFO] [stdout] 872 | /   symlinkat(target: *const c_char, newdirfd: RawFd, linkpath: *const c_char) /
[INFO] [stdout] 873 | |     { target: PathBuf, newdirfd: RawFd, linkpath: PathBuf } -> c_int
[INFO] [stdout] 874 | |     ~ [Desc, File] for [x86_64: 266, aarch64: 36, riscv64: 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] 872 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(symlinkat(target: *const c_char, newdirfd: RawFd, linkpath: *const c_char) /
[INFO] [stdout] 873 |     { target: PathBuf, newdirfd: RawFd, linkpath: PathBuf } -> c_int
[INFO] [stdout] 874 ~     ~ [Desc, File] for [x86_64: 266, aarch64: 36, riscv64: 36)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:876:3
[INFO] [stdout]     |
[INFO] [stdout] 876 |   sync() / {} -> c_int ~ [] for [x86_64: 162, aarch64: 81, riscv64: 81],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 876 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(sync() / {} -> c_int ~ [] for [x86_64: 162, aarch64: 81, riscv64: 81)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:884:3
[INFO] [stdout]     |
[INFO] [stdout] 884 | /   sysfs(option: c_int, arg1: c_ulong, arg2: c_ulong) / { option: c_int, arg1: c_ulong, arg2: c_ulong } -> c_int
[INFO] [stdout] 885 | |     ~ [] for [x86_64: 139],
[INFO] [stdout]     | |_________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 884 ~   <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] 885 ~     ~ [] for [x86_64: 139)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:886:3
[INFO] [stdout]     |
[INFO] [stdout] 886 |   sysinfo(info: *mut sysinfo) / { } -> c_int + { info: sysinfo } ~ [] for [x86_64: 99, aarch64: 179, riscv64: 179],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 886 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(sysinfo(info: *mut sysinfo) / { } -> c_int + { info: sysinfo } ~ [] for [x86_64: 99, aarch64: 179, riscv64: 179)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                               +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:887:3
[INFO] [stdout]     |
[INFO] [stdout] 887 | /   syslog(typ: c_int, buf: *const c_char, len: c_int) / { typ: c_int, buf: CString, len: c_int } -> c_int
[INFO] [stdout] 888 | |     ~ [] for [x86_64: 103, aarch64: 116, riscv64: 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] 887 ~   <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] 888 ~     ~ [] for [x86_64: 103, aarch64: 116, riscv64: 116)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:892:3
[INFO] [stdout]     |
[INFO] [stdout] 892 | /   tgkill(tgid: pid_t, tid: pid_t, sig: c_int) / { tgid: pid_t, tid: pid_t, sig: c_int } -> c_int
[INFO] [stdout] 893 | |     ~ [Signal, Process] for [x86_64: 234, aarch64: 131, riscv64: 131],
[INFO] [stdout]     | |____________________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 892 ~   <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] 893 ~     ~ [Signal, Process] for [x86_64: 234, aarch64: 131, riscv64: 131)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:895:3
[INFO] [stdout]     |
[INFO] [stdout] 895 | /   timer_create(clockid: clockid_t, sevp: *const sigevent, timerid: *mut timer_t) /
[INFO] [stdout] 896 | |     { clockid: clockid_t, sevp: Option<sigevent> } -> c_int + { timerid: InspectResult<timer_t> }
[INFO] [stdout] 897 | |     ~ [] for [x86_64: 222, aarch64: 107, riscv64: 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] 895 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(timer_create(clockid: clockid_t, sevp: *const sigevent, timerid: *mut timer_t) /
[INFO] [stdout] 896 |     { clockid: clockid_t, sevp: Option<sigevent> } -> c_int + { timerid: InspectResult<timer_t> }
[INFO] [stdout] 897 ~     ~ [] for [x86_64: 222, aarch64: 107, riscv64: 107)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:898:3
[INFO] [stdout]     |
[INFO] [stdout] 898 |   timer_delete(timerid: timer_t) / { timerid: timer_t } -> c_int ~ [] for [x86_64: 226, aarch64: 111, riscv64: 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] 898 |   <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)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:899:3
[INFO] [stdout]     |
[INFO] [stdout] 899 |   timer_getoverrun(timerid: timer_t) / { timerid: timer_t } -> c_int ~ [] for [x86_64: 225, aarch64: 109, riscv64: 109],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 899 |   <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)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:900:3
[INFO] [stdout]     |
[INFO] [stdout] 900 | /   timer_gettime(timerid: timer_t, curr_value: *mut itimerspec) / { timerid: timer_t } -> c_int + { curr_value: itimerspec }
[INFO] [stdout] 901 | |     ~ [] for [x86_64: 224, aarch64: 108, riscv64: 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] 900 ~   <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] 901 ~     ~ [] for [x86_64: 224, aarch64: 108, riscv64: 108)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:903:3
[INFO] [stdout]     |
[INFO] [stdout] 903 | /   timer_settime(timerid: timer_t, flags: c_int, new_value: *const itimerspec, old_value: *mut itimerspec) /
[INFO] [stdout] 904 | |     { timerid: timer_t, flags: c_int, new_value: itimerspec } -> c_int + { old_value: Option<itimerspec> }
[INFO] [stdout] 905 | |     ~ [] for [x86_64: 223, aarch64: 110, riscv64: 110],
[INFO] [stdout]     | |_____________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 903 ~   <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] 904 |     { timerid: timer_t, flags: c_int, new_value: itimerspec } -> c_int + { old_value: Option<itimerspec> }
[INFO] [stdout] 905 ~     ~ [] for [x86_64: 223, aarch64: 110, riscv64: 110)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:917:3
[INFO] [stdout]     |
[INFO] [stdout] 917 |   times(buf: *mut tms) / { } -> clock_t + { buf: tms } ~ [] for [x86_64: 100, aarch64: 153, riscv64: 153],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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(times(buf: *mut tms) / { } -> clock_t + { buf: tms } ~ [] for [x86_64: 100, aarch64: 153, riscv64: 153)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                      +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:918:3
[INFO] [stdout]     |
[INFO] [stdout] 918 |   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],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 918 |   <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)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                                                    +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:923:3
[INFO] [stdout]     |
[INFO] [stdout] 923 |   umask(mask: mode_t) / { mask: mode_t } -> mode_t ~ [] for [x86_64: 95, aarch64: 166, riscv64: 166],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the 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(umask(mask: mode_t) / { mask: mode_t } -> mode_t ~ [] for [x86_64: 95, aarch64: 166, riscv64: 166)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:927:3
[INFO] [stdout]     |
[INFO] [stdout] 927 |   uname(buf: *mut utsname) / { } -> c_int + { buf: utsname } ~ [] for [x86_64: 63, aarch64: 160, riscv64: 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] 927 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(uname(buf: *mut utsname) / { } -> c_int + { buf: utsname } ~ [] for [x86_64: 63, aarch64: 160, riscv64: 160)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                           +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:929:3
[INFO] [stdout]     |
[INFO] [stdout] 929 | /   unlinkat(dirfd: RawFd, pathname: *const c_char, flags: c_int) / { dirfd: RawFd, pathname: PathBuf, flags: c_int } -> c_int
[INFO] [stdout] 930 | |     ~ [Desc, File] for [x86_64: 263, aarch64: 35, riscv64: 35],
[INFO] [stdout]     | |_____________________________________________________________^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 929 ~   <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] 930 ~     ~ [Desc, File] for [x86_64: 263, aarch64: 35, riscv64: 35)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:931:3
[INFO] [stdout]     |
[INFO] [stdout] 931 |   unshare(flags: c_int) / { flags: c_int } -> c_int ~ [] for [x86_64: 272, aarch64: 97, riscv64: 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] 931 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(unshare(flags: c_int) / { flags: c_int } -> c_int ~ [] for [x86_64: 272, aarch64: 97, riscv64: 97)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                 +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:932:3
[INFO] [stdout]     |
[INFO] [stdout] 932 |   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] 932 |   <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>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:934:3
[INFO] [stdout]     |
[INFO] [stdout] 934 |   ustat(dev: dev_t, ubuf: *mut ustat) / { dev: dev_t } -> c_int + { ubuf: ustat } ~ [] for [x86_64: 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] 934 |   <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)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                                                     +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:937:3
[INFO] [stdout]     |
[INFO] [stdout] 937 | /   utimensat(dirfd: RawFd, pathname: *const c_char, times: *const timespec, flags: c_int) /
[INFO] [stdout] 938 | |     { dirfd: RawFd, pathname: PathBuf, times: Option<[timespec; 2]>, flags: c_int } -> c_int
[INFO] [stdout] 939 | |     ~ [Desc, File] for [x86_64: 280, aarch64: 88, riscv64: 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] 937 ~   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(utimensat(dirfd: RawFd, pathname: *const c_char, times: *const timespec, flags: c_int) /
[INFO] [stdout] 938 |     { dirfd: RawFd, pathname: PathBuf, times: Option<[timespec; 2]>, flags: c_int } -> c_int
[INFO] [stdout] 939 ~     ~ [Desc, File] for [x86_64: 280, aarch64: 88, riscv64: 88)],
[INFO] [stdout]     |
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stdout] error: useless conversion to the same type: `BitFlags<group::SyscallGroups, u32>` ptrace_syscalls
[INFO] [stdout]    --> src/syscalls.rs:945:3
[INFO] [stdout]     |
[INFO] [stdout] 945 |   vhangup() / {} -> c_int ~ [] for [x86_64: 153, aarch64: 58, riscv64: 58],
[INFO] [stdout]     |   ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
[INFO] [stdout]     |
[INFO] [stdout]     = note: this method call relies on the `impl<T> Into<T> for T` blanket implementation and type inference, which is a semver hazard as a new `impl Into<_>` that affects your type might be added in the future causing type inference errors
[INFO] [stdout] help: you can use the fully-qualified path to avoid triggering this lint
[INFO] [stdout]     |
[INFO] [stdout] 945 |   <BitFlags<group::SyscallGroups, u32> as Into<_>>::into(vhangup() / {} -> c_int ~ [] for [x86_64: 153, aarch64: 58, riscv64: 58)],
[INFO] [stdout]     |   +++++++++++++++++++++++++++++++++++++++++++++++++++++++                                                                       +
[INFO] [stdout] 
[INFO] [stdout] 
[INFO] [stderr] error: could not compile `ptrace-syscalls` (lib) due to 154 previous errors; 1 warning emitted
[INFO] [stderr] warning: build failed, waiting for other jobs to finish...
[INFO] [stderr] error: could not compile `ptrace-syscalls` (lib test) due to 154 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" "fe4508345f6379c155a6309f301ad3dfd3c92b321dec73293c250be96e8a494b", kill_on_drop: false }`
[INFO] running `Command { std: "docker" "rm" "-f" "fe4508345f6379c155a6309f301ad3dfd3c92b321dec73293c250be96e8a494b", kill_on_drop: false }`
[INFO] [stdout] fe4508345f6379c155a6309f301ad3dfd3c92b321dec73293c250be96e8a494b
