Unnecessary parentheses warnings with odd spans since 1.90

[Skgland]

Code

# Cargo.toml

[package]
name = "repro"
version = "0.1.0"
edition = "2024"

[dependencies]

scryer-modular-bitfield = "0.11.4"

[lints.rust]
unused_parens = "deny"

// src/lib.rs

use scryer_modular_bitfield::bitfield;
use scryer_modular_bitfield::specifiers::*;

#[bitfield]
#[repr(u64)]
#[derive(Copy, Clone, Debug, Hash, PartialEq, Eq)]
pub struct UntypedArenaPtr {
    #[allow(unused)]
    ptr: B61,
    m: bool,
    #[allow(unused)]
    padding: B2,
}

pub fn test() {
    dbg!(UntypedArenaPtr::new());
}

Current output

$ cargo +1.90 check
    Checking repro v0.1.0 (/home/bennet/git/tmp/repro)
error: unnecessary parentheses around type
  --> src/lib.rs:10:5
   |
10 |     #[allow(unused)]
   |     ^ help: remove these parentheses
   |
   = note: requested on the command line with `-D unused-parens`

error: unnecessary parentheses around type
  --> src/lib.rs:12:5
   |
12 |     m: bool,
   |     ^ help: remove these parentheses

error: unnecessary parentheses around type
  --> src/lib.rs:13:5
   |
13 |     #[allow(unused)]
   |     ^ help: remove these parentheses

warning: method `m` is never used
  --> src/lib.rs:12:5
   |
 7 | #[repr(u64)]
   | - method in this implementation
...
12 |     m: bool,
   |     ^
   |
   = note: `#[warn(dead_code)]` on by default

warning: `repro` (lib) generated 1 warning
error: could not compile `repro` (lib) due to 3 previous errors; 1 warning emitted

Desired output

$ cargo +1.89 check
    Checking repro v0.1.0 (/home/bennet/git/tmp/repro)
warning: method `m` is never used
  --> src/lib.rs:12:5
   |
7  | #[repr(u64)]
   | - method in this implementation
...
12 |     m: bool,
   |     ^
   |
   = note: `#[warn(dead_code)]` on by default

warning: `repro` (lib) generated 1 warning
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 0.60s

Rationale and extra context

It's rather of seeing a diagnostic for unnecessary parentheses that is pointing nowhere near parenthesis. Also as the offending code is suspected to be macro generated fixing it is non-actionable for the user and as such the diagnostic is confusing.

The involved types all use the #[bitfield] attribute macro, so I suspect it is generating code with unnecessary parenthesis and for some reason they weren't reported prior to 1.90 and for some reason starting with 1.90 they are now reported with odd spans.

Rust Version

$ rustc +1.90 --version --verbose
rustc 1.90.0 (1159e78c4 2025-09-14)
binary: rustc
commit-hash: 1159e78c4747b02ef996e55082b704c09b970588
commit-date: 2025-09-14
host: x86_64-unknown-linux-gnu
release: 1.90.0
LLVM version: 20.1.8

Anything else?

This was reported to the scryer-prolog project in mthom/scryer-prolog#3092

[Urgau]

Are you able to run cargo +nightly rustc --profile=check -- -Zunpretty=expanded on your minimized example and post the relevant part here.

[Skgland]

Full Output

$ cargo +nightly rustc --profile=check -- -Zunpretty=expanded
    Updating crates.io index
  Downloaded quote v1.0.41
  Downloaded 1 crate (30.7KiB) in 0.14s
   Compiling proc-macro2 v1.0.101
   Compiling quote v1.0.41
   Compiling unicode-ident v1.0.19
   Compiling syn v1.0.109
    Checking static_assertions v1.1.0
   Compiling scryer-modular-bitfield-impl v0.11.2
    Checking scryer-modular-bitfield v0.11.4
    Checking repro v0.1.0 (/mnt/f/Git/repro)
warning: unnecessary parentheses around type
 --> src/lib.rs:8:5
  |
8 |     #[allow(unused)]
  |     ^
9 |     ptr: B61,
  |            ^
  |
  = note: `#[warn(unused_parens)]` (part of `#[warn(unused)]`) on by default
help: remove these parentheses
  |
8 ~     [allow(unused)]
9 ~     ptr: B6 ,
  |

warning: unnecessary parentheses around type
  --> src/lib.rs:10:5
   |
10 |     m: bool,
   |     ^     ^
   |
help: remove these parentheses
   |
10 -     m: bool,
10 +     : boo ,
   |

warning: unnecessary parentheses around type
  --> src/lib.rs:11:5
   |
11 |     #[allow(unused)]
   |     ^
12 |     padding: B2,
   |               ^
   |
help: remove these parentheses
   |
11 ~     [allow(unused)]
12 ~     padding: B ,
   |

#![feature(prelude_import)]
#[macro_use]
extern crate std;
#[prelude_import]
use std::prelude::rust_2024::*;
use scryer_modular_bitfield::bitfield;
use scryer_modular_bitfield::specifiers::*;

#[allow(clippy :: identity_op)]
pub struct UntypedArenaPtr {
    bytes: [::core::primitive::u8; (((0usize +
                                                <B61 as ::scryer_modular_bitfield::Specifier>::BITS +
                                            <bool as ::scryer_modular_bitfield::Specifier>::BITS +
                                        <B2 as ::scryer_modular_bitfield::Specifier>::BITS - 1) / 8)
                    + 1) * 8 / 8usize],
}
#[automatically_derived]
#[allow(clippy :: identity_op)]
impl ::core::marker::Copy for UntypedArenaPtr { }
#[automatically_derived]
#[allow(clippy :: identity_op)]
impl ::core::clone::Clone for UntypedArenaPtr {
    #[inline]
    fn clone(&self) -> UntypedArenaPtr {
        let _:
                ::core::clone::AssertParamIsClone<[::core::primitive::u8; (((0usize
                                                            + <B61 as ::scryer_modular_bitfield::Specifier>::BITS +
                                                        <bool as ::scryer_modular_bitfield::Specifier>::BITS +
                                                    <B2 as ::scryer_modular_bitfield::Specifier>::BITS - 1) / 8)
                                + 1) * 8 / 8usize]>;
        *self
    }
}
#[automatically_derived]
#[allow(clippy :: identity_op)]
impl ::core::hash::Hash for UntypedArenaPtr {
    #[inline]
    fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) -> () {
        ::core::hash::Hash::hash(&self.bytes, state)
    }
}
#[automatically_derived]
#[allow(clippy :: identity_op)]
impl ::core::marker::StructuralPartialEq for UntypedArenaPtr { }
#[automatically_derived]
#[allow(clippy :: identity_op)]
impl ::core::cmp::PartialEq for UntypedArenaPtr {
    #[inline]
    fn eq(&self, other: &UntypedArenaPtr) -> bool {
        self.bytes == other.bytes
    }
}
#[automatically_derived]
#[allow(clippy :: identity_op)]
impl ::core::cmp::Eq for UntypedArenaPtr {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {
        let _:
                ::core::cmp::AssertParamIsEq<[::core::primitive::u8; (((0usize
                                                            + <B61 as ::scryer_modular_bitfield::Specifier>::BITS +
                                                        <bool as ::scryer_modular_bitfield::Specifier>::BITS +
                                                    <B2 as ::scryer_modular_bitfield::Specifier>::BITS - 1) / 8)
                                + 1) * 8 / 8usize]>;
    }
}
#[allow(clippy :: identity_op)]
const _: () =
    {
        impl ::scryer_modular_bitfield::private::checks::CheckTotalSizeMultipleOf8
            for UntypedArenaPtr {
            type Size =
                ::scryer_modular_bitfield::private::checks::TotalSize<[(); (0usize
                                    + <B61 as ::scryer_modular_bitfield::Specifier>::BITS +
                                <bool as ::scryer_modular_bitfield::Specifier>::BITS +
                            <B2 as ::scryer_modular_bitfield::Specifier>::BITS) %
                    8usize]>;
        }
    };
impl UntypedArenaPtr {
    #[doc = r" Returns an instance with zero initialized data."]
    #[allow(clippy :: identity_op)]
    pub const fn new() -> Self {
        Self {
            bytes: [0u8;
                    (((0usize +
                                                                <B61 as ::scryer_modular_bitfield::Specifier>::BITS +
                                                            <bool as ::scryer_modular_bitfield::Specifier>::BITS +
                                                        <B2 as ::scryer_modular_bitfield::Specifier>::BITS - 1) / 8)
                                    + 1) * 8 / 8usize],
        }
    }
}
impl UntypedArenaPtr {
    #[doc = r" Returns the underlying bits."]
    #[doc = r""]
    #[doc = r" # Layout"]
    #[doc = r""]
    #[doc =
    r" The returned byte array is layed out in the same way as described"]
    #[doc =
    r" [here](https://docs.rs/modular-bitfield/#generated-structure)."]
    #[inline]
    #[allow(clippy :: identity_op, dead_code)]
    pub const fn into_bytes(self)
        ->
            [::core::primitive::u8; (((0usize +
                                                        <B61 as ::scryer_modular_bitfield::Specifier>::BITS +
                                                    <bool as ::scryer_modular_bitfield::Specifier>::BITS +
                                                <B2 as ::scryer_modular_bitfield::Specifier>::BITS - 1) / 8)
                            + 1) * 8 / 8usize] {
        self.bytes
    }
    #[doc = r" Converts the given bytes directly into the bitfield struct."]
    #[inline]
    #[allow(clippy :: identity_op, dead_code)]
    pub const fn from_bytes(bytes:
            [::core::primitive::u8; (((0usize +
                                                        <B61 as ::scryer_modular_bitfield::Specifier>::BITS +
                                                    <bool as ::scryer_modular_bitfield::Specifier>::BITS +
                                                <B2 as ::scryer_modular_bitfield::Specifier>::BITS - 1) / 8)
                            + 1) * 8 / 8usize]) -> Self {
        Self { bytes }
    }
}
const _: () =
    {
        const _: () = {};
        const _: () = {};
        const _: () = {};
    };
impl UntypedArenaPtr {
    #[doc = "Returns the value of ptr."]
    #[inline]
    #[allow(unused)]
    fn ptr(&self) -> <B61 as ::scryer_modular_bitfield::Specifier>::InOut {
        self.ptr_or_err().expect("value contains invalid bit pattern for field UntypedArenaPtr.ptr")
    }
    #[doc =
    "Returns the value of ptr.\n\n#Errors\n\nIf the returned value contains an invalid bit pattern for ptr."]
    #[inline]
    #[allow(dead_code)]
    #[allow(unused)]
    fn ptr_or_err(&self)
        ->
            ::core::result::Result<<B61 as
            ::scryer_modular_bitfield::Specifier>::InOut,
            ::scryer_modular_bitfield::error::InvalidBitPattern<<B61 as
            ::scryer_modular_bitfield::Specifier>::Bytes>> {
        let __bf_read: <B61 as ::scryer_modular_bitfield::Specifier>::Bytes =
            {
                ::scryer_modular_bitfield::private::read_specifier::<B61>(&self.bytes[..],
                    0usize)
            };
        <B61 as ::scryer_modular_bitfield::Specifier>::from_bytes(__bf_read)
    }
    #[doc =
    "Returns a copy of the bitfield with the value of ptr set to the given value.\n\n#Panics\n\nIf the given value is out of bounds for ptr."]
    #[inline]
    #[allow(dead_code)]
    #[allow(unused)]
    fn with_ptr(mut self,
        new_val: <B61 as ::scryer_modular_bitfield::Specifier>::InOut)
        -> Self {
        self.set_ptr(new_val);
        self
    }
    #[doc =
    "Returns a copy of the bitfield with the value of ptr set to the given value.\n\n#Errors\n\nIf the given value is out of bounds for ptr."]
    #[inline]
    #[allow(dead_code)]
    #[allow(unused)]
    fn with_ptr_checked(mut self,
        new_val: <B61 as ::scryer_modular_bitfield::Specifier>::InOut)
        ->
            ::core::result::Result<Self,
            ::scryer_modular_bitfield::error::OutOfBounds> {
        self.set_ptr_checked(new_val)?;
        ::core::result::Result::Ok(self)
    }
    #[doc =
    "Sets the value of ptr to the given value.\n\n#Panics\n\nIf the given value is out of bounds for ptr."]
    #[inline]
    #[allow(dead_code)]
    #[allow(unused)]
    fn set_ptr(&mut self,
        new_val: <B61 as ::scryer_modular_bitfield::Specifier>::InOut) {
        self.set_ptr_checked(new_val).expect("value out of bounds for field UntypedArenaPtr.ptr")
    }
    #[doc =
    "Sets the value of ptr to the given value.\n\n#Errors\n\nIf the given value is out of bounds for ptr."]
    #[inline]
    #[allow(unused)]
    fn set_ptr_checked(&mut self,
        new_val: <B61 as ::scryer_modular_bitfield::Specifier>::InOut)
        ->
            ::core::result::Result<(),
            ::scryer_modular_bitfield::error::OutOfBounds> {
        let __bf_base_bits: ::core::primitive::usize =
            8usize *
                ::core::mem::size_of::<<B61 as
                        ::scryer_modular_bitfield::Specifier>::Bytes>();
        let __bf_max_value:
                <B61 as ::scryer_modular_bitfield::Specifier>::Bytes =
            {
                !0 >>
                    (__bf_base_bits -
                            <B61 as ::scryer_modular_bitfield::Specifier>::BITS)
            };
        let __bf_spec_bits: ::core::primitive::usize =
            <B61 as ::scryer_modular_bitfield::Specifier>::BITS;
        let __bf_raw_val:
                <B61 as ::scryer_modular_bitfield::Specifier>::Bytes =
            {
                    <B61 as
                            ::scryer_modular_bitfield::Specifier>::into_bytes(new_val)
                }?;
        if !(__bf_base_bits == __bf_spec_bits ||
                        __bf_raw_val <= __bf_max_value) {
            return ::core::result::Result::Err(::scryer_modular_bitfield::error::OutOfBounds)
        }
        ::scryer_modular_bitfield::private::write_specifier::<B61>(&mut self.bytes[..],
            0usize, __bf_raw_val);
        ::core::result::Result::Ok(())
    }
    #[doc = "Returns the value of m."]
    #[inline]
    fn m(&self) -> <bool as ::scryer_modular_bitfield::Specifier>::InOut {
        self.m_or_err().expect("value contains invalid bit pattern for field UntypedArenaPtr.m")
    }
    #[doc =
    "Returns the value of m.\n\n#Errors\n\nIf the returned value contains an invalid bit pattern for m."]
    #[inline]
    #[allow(dead_code)]
    fn m_or_err(&self)
        ->
            ::core::result::Result<<bool as
            ::scryer_modular_bitfield::Specifier>::InOut,
            ::scryer_modular_bitfield::error::InvalidBitPattern<<bool as
            ::scryer_modular_bitfield::Specifier>::Bytes>> {
        let __bf_read: <bool as ::scryer_modular_bitfield::Specifier>::Bytes =
            {
                ::scryer_modular_bitfield::private::read_specifier::<bool>(&self.bytes[..],
                    0usize +
                        <B61 as ::scryer_modular_bitfield::Specifier>::BITS)
            };
        <bool as ::scryer_modular_bitfield::Specifier>::from_bytes(__bf_read)
    }
    #[doc =
    "Returns a copy of the bitfield with the value of m set to the given value.\n\n#Panics\n\nIf the given value is out of bounds for m."]
    #[inline]
    #[allow(dead_code)]
    fn with_m(mut self,
        new_val: <bool as ::scryer_modular_bitfield::Specifier>::InOut)
        -> Self {
        self.set_m(new_val);
        self
    }
    #[doc =
    "Returns a copy of the bitfield with the value of m set to the given value.\n\n#Errors\n\nIf the given value is out of bounds for m."]
    #[inline]
    #[allow(dead_code)]
    fn with_m_checked(mut self,
        new_val: <bool as ::scryer_modular_bitfield::Specifier>::InOut)
        ->
            ::core::result::Result<Self,
            ::scryer_modular_bitfield::error::OutOfBounds> {
        self.set_m_checked(new_val)?;
        ::core::result::Result::Ok(self)
    }
    #[doc =
    "Sets the value of m to the given value.\n\n#Panics\n\nIf the given value is out of bounds for m."]
    #[inline]
    #[allow(dead_code)]
    fn set_m(&mut self,
        new_val: <bool as ::scryer_modular_bitfield::Specifier>::InOut) {
        self.set_m_checked(new_val).expect("value out of bounds for field UntypedArenaPtr.m")
    }
    #[doc =
    "Sets the value of m to the given value.\n\n#Errors\n\nIf the given value is out of bounds for m."]
    #[inline]
    fn set_m_checked(&mut self,
        new_val: <bool as ::scryer_modular_bitfield::Specifier>::InOut)
        ->
            ::core::result::Result<(),
            ::scryer_modular_bitfield::error::OutOfBounds> {
        let __bf_base_bits: ::core::primitive::usize =
            8usize *
                ::core::mem::size_of::<<bool as
                        ::scryer_modular_bitfield::Specifier>::Bytes>();
        let __bf_max_value:
                <bool as ::scryer_modular_bitfield::Specifier>::Bytes =
            {
                !0 >>
                    (__bf_base_bits -
                            <bool as ::scryer_modular_bitfield::Specifier>::BITS)
            };
        let __bf_spec_bits: ::core::primitive::usize =
            <bool as ::scryer_modular_bitfield::Specifier>::BITS;
        let __bf_raw_val:
                <bool as ::scryer_modular_bitfield::Specifier>::Bytes =
            {
                    <bool as
                            ::scryer_modular_bitfield::Specifier>::into_bytes(new_val)
                }?;
        if !(__bf_base_bits == __bf_spec_bits ||
                        __bf_raw_val <= __bf_max_value) {
            return ::core::result::Result::Err(::scryer_modular_bitfield::error::OutOfBounds)
        }
        ::scryer_modular_bitfield::private::write_specifier::<bool>(&mut self.bytes[..],
            0usize + <B61 as ::scryer_modular_bitfield::Specifier>::BITS,
            __bf_raw_val);
        ::core::result::Result::Ok(())
    }
    #[doc = "Returns the value of padding."]
    #[inline]
    #[allow(unused)]
    fn padding(&self) -> <B2 as ::scryer_modular_bitfield::Specifier>::InOut {
        self.padding_or_err().expect("value contains invalid bit pattern for field UntypedArenaPtr.padding")
    }
    #[doc =
    "Returns the value of padding.\n\n#Errors\n\nIf the returned value contains an invalid bit pattern for padding."]
    #[inline]
    #[allow(dead_code)]
    #[allow(unused)]
    fn padding_or_err(&self)
        ->
            ::core::result::Result<<B2 as
            ::scryer_modular_bitfield::Specifier>::InOut,
            ::scryer_modular_bitfield::error::InvalidBitPattern<<B2 as
            ::scryer_modular_bitfield::Specifier>::Bytes>> {
        let __bf_read: <B2 as ::scryer_modular_bitfield::Specifier>::Bytes =
            {
                ::scryer_modular_bitfield::private::read_specifier::<B2>(&self.bytes[..],
                    0usize + <B61 as ::scryer_modular_bitfield::Specifier>::BITS
                        + <bool as ::scryer_modular_bitfield::Specifier>::BITS)
            };
        <B2 as ::scryer_modular_bitfield::Specifier>::from_bytes(__bf_read)
    }
    #[doc =
    "Returns a copy of the bitfield with the value of padding set to the given value.\n\n#Panics\n\nIf the given value is out of bounds for padding."]
    #[inline]
    #[allow(dead_code)]
    #[allow(unused)]
    fn with_padding(mut self,
        new_val: <B2 as ::scryer_modular_bitfield::Specifier>::InOut)
        -> Self {
        self.set_padding(new_val);
        self
    }
    #[doc =
    "Returns a copy of the bitfield with the value of padding set to the given value.\n\n#Errors\n\nIf the given value is out of bounds for padding."]
    #[inline]
    #[allow(dead_code)]
    #[allow(unused)]
    fn with_padding_checked(mut self,
        new_val: <B2 as ::scryer_modular_bitfield::Specifier>::InOut)
        ->
            ::core::result::Result<Self,
            ::scryer_modular_bitfield::error::OutOfBounds> {
        self.set_padding_checked(new_val)?;
        ::core::result::Result::Ok(self)
    }
    #[doc =
    "Sets the value of padding to the given value.\n\n#Panics\n\nIf the given value is out of bounds for padding."]
    #[inline]
    #[allow(dead_code)]
    #[allow(unused)]
    fn set_padding(&mut self,
        new_val: <B2 as ::scryer_modular_bitfield::Specifier>::InOut) {
        self.set_padding_checked(new_val).expect("value out of bounds for field UntypedArenaPtr.padding")
    }
    #[doc =
    "Sets the value of padding to the given value.\n\n#Errors\n\nIf the given value is out of bounds for padding."]
    #[inline]
    #[allow(unused)]
    fn set_padding_checked(&mut self,
        new_val: <B2 as ::scryer_modular_bitfield::Specifier>::InOut)
        ->
            ::core::result::Result<(),
            ::scryer_modular_bitfield::error::OutOfBounds> {
        let __bf_base_bits: ::core::primitive::usize =
            8usize *
                ::core::mem::size_of::<<B2 as
                        ::scryer_modular_bitfield::Specifier>::Bytes>();
        let __bf_max_value:
                <B2 as ::scryer_modular_bitfield::Specifier>::Bytes =
            {
                !0 >>
                    (__bf_base_bits -
                            <B2 as ::scryer_modular_bitfield::Specifier>::BITS)
            };
        let __bf_spec_bits: ::core::primitive::usize =
            <B2 as ::scryer_modular_bitfield::Specifier>::BITS;
        let __bf_raw_val:
                <B2 as ::scryer_modular_bitfield::Specifier>::Bytes =
            {
                    <B2 as
                            ::scryer_modular_bitfield::Specifier>::into_bytes(new_val)
                }?;
        if !(__bf_base_bits == __bf_spec_bits ||
                        __bf_raw_val <= __bf_max_value) {
            return ::core::result::Result::Err(::scryer_modular_bitfield::error::OutOfBounds)
        }
        ::scryer_modular_bitfield::private::write_specifier::<B2>(&mut self.bytes[..],
            0usize + <B61 as ::scryer_modular_bitfield::Specifier>::BITS +
                <bool as ::scryer_modular_bitfield::Specifier>::BITS,
            __bf_raw_val);
        ::core::result::Result::Ok(())
    }
}
#[allow(clippy :: identity_op)]
impl ::core::convert::From<::core::primitive::u64> for UntypedArenaPtr where
    [(); 0usize + <B61 as ::scryer_modular_bitfield::Specifier>::BITS +
            <bool as ::scryer_modular_bitfield::Specifier>::BITS +
        <B2 as
            ::scryer_modular_bitfield::Specifier>::BITS]: ::scryer_modular_bitfield::private::IsU64Compatible
    {
    #[inline]
    fn from(__bf_prim: ::core::primitive::u64) -> Self {
        Self { bytes: <::core::primitive::u64>::to_le_bytes(__bf_prim) }
    }
}
#[allow(clippy :: identity_op)]
impl ::core::convert::From<UntypedArenaPtr> for ::core::primitive::u64 where
    [(); 0usize + <B61 as ::scryer_modular_bitfield::Specifier>::BITS +
            <bool as ::scryer_modular_bitfield::Specifier>::BITS +
        <B2 as
            ::scryer_modular_bitfield::Specifier>::BITS]: ::scryer_modular_bitfield::private::IsU64Compatible
    {
    #[inline]
    fn from(__bf_bitfield: UntypedArenaPtr) -> Self {
        <Self>::from_le_bytes(__bf_bitfield.bytes)
    }
}
impl ::core::fmt::Debug for UntypedArenaPtr {
    fn fmt(&self, __bf_f: &mut ::core::fmt::Formatter<'_>)
        -> ::core::fmt::Result {
        __bf_f.debug_struct("UntypedArenaPtr").field("ptr",
                        self.ptr_or_err().as_ref().map(|__bf_field|
                                    __bf_field as
                                        &dyn ::core::fmt::Debug).unwrap_or_else(|__bf_err|
                                __bf_err as
                                    &dyn ::core::fmt::Debug)).field("m",
                    self.m_or_err().as_ref().map(|__bf_field|
                                __bf_field as
                                    &dyn ::core::fmt::Debug).unwrap_or_else(|__bf_err|
                            __bf_err as
                                &dyn ::core::fmt::Debug)).field("padding",
                self.padding_or_err().as_ref().map(|__bf_field|
                            __bf_field as
                                &dyn ::core::fmt::Debug).unwrap_or_else(|__bf_err|
                        __bf_err as &dyn ::core::fmt::Debug)).finish()
    }
}

pub fn test() {
    match UntypedArenaPtr::new() {
        tmp => {
            {
                ::std::io::_eprint(format_args!("[{0}:{1}:{2}] {3} = {4:#?}\n",
                        "src/lib.rs", 16u32, 5u32, "UntypedArenaPtr::new()",
                        &&tmp as &dyn ::std::fmt::Debug));
            };
            tmp
        }
    };
}
warning: `repro` (lib) generated 3 warnings (run `cargo fix --lib -p repro` to apply 3 suggestions)
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 6.89s

Adjusted Output to make it compile

Added a few missing features and removed some unused imports.

// lib.rs

#![feature(prelude_import)]
#![feature(derive_clone_copy)]
#![feature(print_internals)]
#![feature(derive_eq)]
#![feature(coverage_attribute)]
#![feature(structural_match)]

use scryer_modular_bitfield::specifiers::*;

#[allow(clippy::identity_op)]
pub struct UntypedArenaPtr {
    bytes: [::core::primitive::u8;
        (((0usize
            + <B61 as ::scryer_modular_bitfield::Specifier>::BITS
            + <bool as ::scryer_modular_bitfield::Specifier>::BITS
            + <B2 as ::scryer_modular_bitfield::Specifier>::BITS
            - 1)
            / 8)
            + 1)
            * 8
            / 8usize],
}
#[automatically_derived]
#[allow(clippy::identity_op)]
impl ::core::marker::Copy for UntypedArenaPtr {}
#[automatically_derived]
#[allow(clippy::identity_op)]
impl ::core::clone::Clone for UntypedArenaPtr {
    #[inline]
    fn clone(&self) -> UntypedArenaPtr {
        let _: ::core::clone::AssertParamIsClone<
            [::core::primitive::u8;
                (((0usize
                    + <B61 as ::scryer_modular_bitfield::Specifier>::BITS
                    + <bool as ::scryer_modular_bitfield::Specifier>::BITS
                    + <B2 as ::scryer_modular_bitfield::Specifier>::BITS
                    - 1)
                    / 8)
                    + 1)
                    * 8
                    / 8usize],
        >;
        *self
    }
}
#[automatically_derived]
#[allow(clippy::identity_op)]
impl ::core::hash::Hash for UntypedArenaPtr {
    #[inline]
    fn hash<__H: ::core::hash::Hasher>(&self, state: &mut __H) -> () {
        ::core::hash::Hash::hash(&self.bytes, state)
    }
}
#[automatically_derived]
#[allow(clippy::identity_op)]
impl ::core::marker::StructuralPartialEq for UntypedArenaPtr {}
#[automatically_derived]
#[allow(clippy::identity_op)]
impl ::core::cmp::PartialEq for UntypedArenaPtr {
    #[inline]
    fn eq(&self, other: &UntypedArenaPtr) -> bool {
        self.bytes == other.bytes
    }
}
#[automatically_derived]
#[allow(clippy::identity_op)]
impl ::core::cmp::Eq for UntypedArenaPtr {
    #[inline]
    #[doc(hidden)]
    #[coverage(off)]
    fn assert_receiver_is_total_eq(&self) -> () {
        let _: ::core::cmp::AssertParamIsEq<
            [::core::primitive::u8;
                (((0usize
                    + <B61 as ::scryer_modular_bitfield::Specifier>::BITS
                    + <bool as ::scryer_modular_bitfield::Specifier>::BITS
                    + <B2 as ::scryer_modular_bitfield::Specifier>::BITS
                    - 1)
                    / 8)
                    + 1)
                    * 8
                    / 8usize],
        >;
    }
}
#[allow(clippy::identity_op)]
const _: () = {
    impl ::scryer_modular_bitfield::private::checks::CheckTotalSizeMultipleOf8 for UntypedArenaPtr {
        type Size = ::scryer_modular_bitfield::private::checks::TotalSize<
            [(); (0usize
                + <B61 as ::scryer_modular_bitfield::Specifier>::BITS
                + <bool as ::scryer_modular_bitfield::Specifier>::BITS
                + <B2 as ::scryer_modular_bitfield::Specifier>::BITS)
                % 8usize],
        >;
    }
};
impl UntypedArenaPtr {
    #[doc = r" Returns an instance with zero initialized data."]
    #[allow(clippy::identity_op)]
    pub const fn new() -> Self {
        Self {
            bytes: [0u8; (((0usize
                + <B61 as ::scryer_modular_bitfield::Specifier>::BITS
                + <bool as ::scryer_modular_bitfield::Specifier>::BITS
                + <B2 as ::scryer_modular_bitfield::Specifier>::BITS
                - 1)
                / 8)
                + 1)
                * 8
                / 8usize],
        }
    }
}
impl UntypedArenaPtr {
    #[doc = r" Returns the underlying bits."]
    #[doc = r""]
    #[doc = r" # Layout"]
    #[doc = r""]
    #[doc = r" The returned byte array is layed out in the same way as described"]
    #[doc = r" [here](https://docs.rs/modular-bitfield/#generated-structure)."]
    #[inline]
    #[allow(clippy::identity_op, dead_code)]
    pub const fn into_bytes(
        self,
    ) -> [::core::primitive::u8;
        (((0usize
            + <B61 as ::scryer_modular_bitfield::Specifier>::BITS
            + <bool as ::scryer_modular_bitfield::Specifier>::BITS
            + <B2 as ::scryer_modular_bitfield::Specifier>::BITS
            - 1)
            / 8)
            + 1)
            * 8
            / 8usize] {
        self.bytes
    }
    #[doc = r" Converts the given bytes directly into the bitfield struct."]
    #[inline]
    #[allow(clippy::identity_op, dead_code)]
    pub const fn from_bytes(
        bytes: [::core::primitive::u8;
            (((0usize
                + <B61 as ::scryer_modular_bitfield::Specifier>::BITS
                + <bool as ::scryer_modular_bitfield::Specifier>::BITS
                + <B2 as ::scryer_modular_bitfield::Specifier>::BITS
                - 1)
                / 8)
                + 1)
                * 8
                / 8usize],
    ) -> Self {
        Self { bytes }
    }
}
const _: () = {
    const _: () = {};
    const _: () = {};
    const _: () = {};
};
impl UntypedArenaPtr {
    #[doc = "Returns the value of ptr."]
    #[inline]
    #[allow(unused)]
    fn ptr(&self) -> <B61 as ::scryer_modular_bitfield::Specifier>::InOut {
        self.ptr_or_err()
            .expect("value contains invalid bit pattern for field UntypedArenaPtr.ptr")
    }
    #[doc = "Returns the value of ptr.\n\n#Errors\n\nIf the returned value contains an invalid bit pattern for ptr."]
    #[inline]
    #[allow(dead_code)]
    #[allow(unused)]
    fn ptr_or_err(
        &self,
    ) -> ::core::result::Result<
        <B61 as ::scryer_modular_bitfield::Specifier>::InOut,
        ::scryer_modular_bitfield::error::InvalidBitPattern<
            <B61 as ::scryer_modular_bitfield::Specifier>::Bytes,
        >,
    > {
        let __bf_read: <B61 as ::scryer_modular_bitfield::Specifier>::Bytes =
            { ::scryer_modular_bitfield::private::read_specifier::<B61>(&self.bytes[..], 0usize) };
        <B61 as ::scryer_modular_bitfield::Specifier>::from_bytes(__bf_read)
    }
    #[doc = "Returns a copy of the bitfield with the value of ptr set to the given value.\n\n#Panics\n\nIf the given value is out of bounds for ptr."]
    #[inline]
    #[allow(dead_code)]
    #[allow(unused)]
    fn with_ptr(mut self, new_val: <B61 as ::scryer_modular_bitfield::Specifier>::InOut) -> Self {
        self.set_ptr(new_val);
        self
    }
    #[doc = "Returns a copy of the bitfield with the value of ptr set to the given value.\n\n#Errors\n\nIf the given value is out of bounds for ptr."]
    #[inline]
    #[allow(dead_code)]
    #[allow(unused)]
    fn with_ptr_checked(
        mut self,
        new_val: <B61 as ::scryer_modular_bitfield::Specifier>::InOut,
    ) -> ::core::result::Result<Self, ::scryer_modular_bitfield::error::OutOfBounds> {
        self.set_ptr_checked(new_val)?;
        ::core::result::Result::Ok(self)
    }
    #[doc = "Sets the value of ptr to the given value.\n\n#Panics\n\nIf the given value is out of bounds for ptr."]
    #[inline]
    #[allow(dead_code)]
    #[allow(unused)]
    fn set_ptr(&mut self, new_val: <B61 as ::scryer_modular_bitfield::Specifier>::InOut) {
        self.set_ptr_checked(new_val)
            .expect("value out of bounds for field UntypedArenaPtr.ptr")
    }
    #[doc = "Sets the value of ptr to the given value.\n\n#Errors\n\nIf the given value is out of bounds for ptr."]
    #[inline]
    #[allow(unused)]
    fn set_ptr_checked(
        &mut self,
        new_val: <B61 as ::scryer_modular_bitfield::Specifier>::InOut,
    ) -> ::core::result::Result<(), ::scryer_modular_bitfield::error::OutOfBounds> {
        let __bf_base_bits: ::core::primitive::usize =
            8usize * ::core::mem::size_of::<<B61 as ::scryer_modular_bitfield::Specifier>::Bytes>();
        let __bf_max_value: <B61 as ::scryer_modular_bitfield::Specifier>::Bytes =
            { !0 >> (__bf_base_bits - <B61 as ::scryer_modular_bitfield::Specifier>::BITS) };
        let __bf_spec_bits: ::core::primitive::usize =
            <B61 as ::scryer_modular_bitfield::Specifier>::BITS;
        let __bf_raw_val: <B61 as ::scryer_modular_bitfield::Specifier>::Bytes =
            { <B61 as ::scryer_modular_bitfield::Specifier>::into_bytes(new_val) }?;
        if !(__bf_base_bits == __bf_spec_bits || __bf_raw_val <= __bf_max_value) {
            return ::core::result::Result::Err(::scryer_modular_bitfield::error::OutOfBounds);
        }
        ::scryer_modular_bitfield::private::write_specifier::<B61>(
            &mut self.bytes[..],
            0usize,
            __bf_raw_val,
        );
        ::core::result::Result::Ok(())
    }
    #[doc = "Returns the value of m."]
    #[inline]
    fn m(&self) -> <bool as ::scryer_modular_bitfield::Specifier>::InOut {
        self.m_or_err()
            .expect("value contains invalid bit pattern for field UntypedArenaPtr.m")
    }
    #[doc = "Returns the value of m.\n\n#Errors\n\nIf the returned value contains an invalid bit pattern for m."]
    #[inline]
    #[allow(dead_code)]
    fn m_or_err(
        &self,
    ) -> ::core::result::Result<
        <bool as ::scryer_modular_bitfield::Specifier>::InOut,
        ::scryer_modular_bitfield::error::InvalidBitPattern<
            <bool as ::scryer_modular_bitfield::Specifier>::Bytes,
        >,
    > {
        let __bf_read: <bool as ::scryer_modular_bitfield::Specifier>::Bytes = {
            ::scryer_modular_bitfield::private::read_specifier::<bool>(
                &self.bytes[..],
                0usize + <B61 as ::scryer_modular_bitfield::Specifier>::BITS,
            )
        };
        <bool as ::scryer_modular_bitfield::Specifier>::from_bytes(__bf_read)
    }
    #[doc = "Returns a copy of the bitfield with the value of m set to the given value.\n\n#Panics\n\nIf the given value is out of bounds for m."]
    #[inline]
    #[allow(dead_code)]
    fn with_m(mut self, new_val: <bool as ::scryer_modular_bitfield::Specifier>::InOut) -> Self {
        self.set_m(new_val);
        self
    }
    #[doc = "Returns a copy of the bitfield with the value of m set to the given value.\n\n#Errors\n\nIf the given value is out of bounds for m."]
    #[inline]
    #[allow(dead_code)]
    fn with_m_checked(
        mut self,
        new_val: <bool as ::scryer_modular_bitfield::Specifier>::InOut,
    ) -> ::core::result::Result<Self, ::scryer_modular_bitfield::error::OutOfBounds> {
        self.set_m_checked(new_val)?;
        ::core::result::Result::Ok(self)
    }
    #[doc = "Sets the value of m to the given value.\n\n#Panics\n\nIf the given value is out of bounds for m."]
    #[inline]
    #[allow(dead_code)]
    fn set_m(&mut self, new_val: <bool as ::scryer_modular_bitfield::Specifier>::InOut) {
        self.set_m_checked(new_val)
            .expect("value out of bounds for field UntypedArenaPtr.m")
    }
    #[doc = "Sets the value of m to the given value.\n\n#Errors\n\nIf the given value is out of bounds for m."]
    #[inline]
    fn set_m_checked(
        &mut self,
        new_val: <bool as ::scryer_modular_bitfield::Specifier>::InOut,
    ) -> ::core::result::Result<(), ::scryer_modular_bitfield::error::OutOfBounds> {
        let __bf_base_bits: ::core::primitive::usize = 8usize
            * ::core::mem::size_of::<<bool as ::scryer_modular_bitfield::Specifier>::Bytes>();
        let __bf_max_value: <bool as ::scryer_modular_bitfield::Specifier>::Bytes =
            { !0 >> (__bf_base_bits - <bool as ::scryer_modular_bitfield::Specifier>::BITS) };
        let __bf_spec_bits: ::core::primitive::usize =
            <bool as ::scryer_modular_bitfield::Specifier>::BITS;
        let __bf_raw_val: <bool as ::scryer_modular_bitfield::Specifier>::Bytes =
            { <bool as ::scryer_modular_bitfield::Specifier>::into_bytes(new_val) }?;
        if !(__bf_base_bits == __bf_spec_bits || __bf_raw_val <= __bf_max_value) {
            return ::core::result::Result::Err(::scryer_modular_bitfield::error::OutOfBounds);
        }
        ::scryer_modular_bitfield::private::write_specifier::<bool>(
            &mut self.bytes[..],
            0usize + <B61 as ::scryer_modular_bitfield::Specifier>::BITS,
            __bf_raw_val,
        );
        ::core::result::Result::Ok(())
    }
    #[doc = "Returns the value of padding."]
    #[inline]
    #[allow(unused)]
    fn padding(&self) -> <B2 as ::scryer_modular_bitfield::Specifier>::InOut {
        self.padding_or_err()
            .expect("value contains invalid bit pattern for field UntypedArenaPtr.padding")
    }
    #[doc = "Returns the value of padding.\n\n#Errors\n\nIf the returned value contains an invalid bit pattern for padding."]
    #[inline]
    #[allow(dead_code)]
    #[allow(unused)]
    fn padding_or_err(
        &self,
    ) -> ::core::result::Result<
        <B2 as ::scryer_modular_bitfield::Specifier>::InOut,
        ::scryer_modular_bitfield::error::InvalidBitPattern<
            <B2 as ::scryer_modular_bitfield::Specifier>::Bytes,
        >,
    > {
        let __bf_read: <B2 as ::scryer_modular_bitfield::Specifier>::Bytes = {
            ::scryer_modular_bitfield::private::read_specifier::<B2>(
                &self.bytes[..],
                0usize
                    + <B61 as ::scryer_modular_bitfield::Specifier>::BITS
                    + <bool as ::scryer_modular_bitfield::Specifier>::BITS,
            )
        };
        <B2 as ::scryer_modular_bitfield::Specifier>::from_bytes(__bf_read)
    }
    #[doc = "Returns a copy of the bitfield with the value of padding set to the given value.\n\n#Panics\n\nIf the given value is out of bounds for padding."]
    #[inline]
    #[allow(dead_code)]
    #[allow(unused)]
    fn with_padding(
        mut self,
        new_val: <B2 as ::scryer_modular_bitfield::Specifier>::InOut,
    ) -> Self {
        self.set_padding(new_val);
        self
    }
    #[doc = "Returns a copy of the bitfield with the value of padding set to the given value.\n\n#Errors\n\nIf the given value is out of bounds for padding."]
    #[inline]
    #[allow(dead_code)]
    #[allow(unused)]
    fn with_padding_checked(
        mut self,
        new_val: <B2 as ::scryer_modular_bitfield::Specifier>::InOut,
    ) -> ::core::result::Result<Self, ::scryer_modular_bitfield::error::OutOfBounds> {
        self.set_padding_checked(new_val)?;
        ::core::result::Result::Ok(self)
    }
    #[doc = "Sets the value of padding to the given value.\n\n#Panics\n\nIf the given value is out of bounds for padding."]
    #[inline]
    #[allow(dead_code)]
    #[allow(unused)]
    fn set_padding(&mut self, new_val: <B2 as ::scryer_modular_bitfield::Specifier>::InOut) {
        self.set_padding_checked(new_val)
            .expect("value out of bounds for field UntypedArenaPtr.padding")
    }
    #[doc = "Sets the value of padding to the given value.\n\n#Errors\n\nIf the given value is out of bounds for padding."]
    #[inline]
    #[allow(unused)]
    fn set_padding_checked(
        &mut self,
        new_val: <B2 as ::scryer_modular_bitfield::Specifier>::InOut,
    ) -> ::core::result::Result<(), ::scryer_modular_bitfield::error::OutOfBounds> {
        let __bf_base_bits: ::core::primitive::usize =
            8usize * ::core::mem::size_of::<<B2 as ::scryer_modular_bitfield::Specifier>::Bytes>();
        let __bf_max_value: <B2 as ::scryer_modular_bitfield::Specifier>::Bytes =
            { !0 >> (__bf_base_bits - <B2 as ::scryer_modular_bitfield::Specifier>::BITS) };
        let __bf_spec_bits: ::core::primitive::usize =
            <B2 as ::scryer_modular_bitfield::Specifier>::BITS;
        let __bf_raw_val: <B2 as ::scryer_modular_bitfield::Specifier>::Bytes =
            { <B2 as ::scryer_modular_bitfield::Specifier>::into_bytes(new_val) }?;
        if !(__bf_base_bits == __bf_spec_bits || __bf_raw_val <= __bf_max_value) {
            return ::core::result::Result::Err(::scryer_modular_bitfield::error::OutOfBounds);
        }
        ::scryer_modular_bitfield::private::write_specifier::<B2>(
            &mut self.bytes[..],
            0usize
                + <B61 as ::scryer_modular_bitfield::Specifier>::BITS
                + <bool as ::scryer_modular_bitfield::Specifier>::BITS,
            __bf_raw_val,
        );
        ::core::result::Result::Ok(())
    }
}
#[allow(clippy::identity_op)]
impl ::core::convert::From<::core::primitive::u64> for UntypedArenaPtr
where
    [(); 0usize
        + <B61 as ::scryer_modular_bitfield::Specifier>::BITS
        + <bool as ::scryer_modular_bitfield::Specifier>::BITS
        + <B2 as ::scryer_modular_bitfield::Specifier>::BITS]:
        ::scryer_modular_bitfield::private::IsU64Compatible,
{
    #[inline]
    fn from(__bf_prim: ::core::primitive::u64) -> Self {
        Self {
            bytes: <::core::primitive::u64>::to_le_bytes(__bf_prim),
        }
    }
}
#[allow(clippy::identity_op)]
impl ::core::convert::From<UntypedArenaPtr> for ::core::primitive::u64
where
    [(); 0usize
        + <B61 as ::scryer_modular_bitfield::Specifier>::BITS
        + <bool as ::scryer_modular_bitfield::Specifier>::BITS
        + <B2 as ::scryer_modular_bitfield::Specifier>::BITS]:
        ::scryer_modular_bitfield::private::IsU64Compatible,
{
    #[inline]
    fn from(__bf_bitfield: UntypedArenaPtr) -> Self {
        <Self>::from_le_bytes(__bf_bitfield.bytes)
    }
}
impl ::core::fmt::Debug for UntypedArenaPtr {
    fn fmt(&self, __bf_f: &mut ::core::fmt::Formatter<'_>) -> ::core::fmt::Result {
        __bf_f
            .debug_struct("UntypedArenaPtr")
            .field(
                "ptr",
                self.ptr_or_err()
                    .as_ref()
                    .map(|__bf_field| __bf_field as &dyn ::core::fmt::Debug)
                    .unwrap_or_else(|__bf_err| __bf_err as &dyn ::core::fmt::Debug),
            )
            .field(
                "m",
                self.m_or_err()
                    .as_ref()
                    .map(|__bf_field| __bf_field as &dyn ::core::fmt::Debug)
                    .unwrap_or_else(|__bf_err| __bf_err as &dyn ::core::fmt::Debug),
            )
            .field(
                "padding",
                self.padding_or_err()
                    .as_ref()
                    .map(|__bf_field| __bf_field as &dyn ::core::fmt::Debug)
                    .unwrap_or_else(|__bf_err| __bf_err as &dyn ::core::fmt::Debug),
            )
            .finish()
    }
}

pub fn test() {
    match UntypedArenaPtr::new() {
        tmp => {
            {
                ::std::io::_eprint(format_args!(
                    "[{0}:{1}:{2}] {3} = {4:#?}\n",
                    "src/lib.rs",
                    16u32,
                    5u32,
                    "UntypedArenaPtr::new()",
                    &&tmp as &dyn ::std::fmt::Debug
                ));
            };
            tmp
        }
    };
}

Remove use of nightly features

// lib.rs

use scryer_modular_bitfield::specifiers::*;

#[allow(clippy::identity_op)]
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
pub struct UntypedArenaPtr {
    bytes: [::core::primitive::u8;
        (((0usize
            + <B61 as ::scryer_modular_bitfield::Specifier>::BITS
            + <bool as ::scryer_modular_bitfield::Specifier>::BITS
            + <B2 as ::scryer_modular_bitfield::Specifier>::BITS
            - 1)
            / 8)
            + 1)
            * 8
            / 8usize],
}

#[allow(clippy::identity_op)]
const _: () = {
    impl ::scryer_modular_bitfield::private::checks::CheckTotalSizeMultipleOf8 for UntypedArenaPtr {
        type Size = ::scryer_modular_bitfield::private::checks::TotalSize<
            [(); (0usize
                + <B61 as ::scryer_modular_bitfield::Specifier>::BITS
                + <bool as ::scryer_modular_bitfield::Specifier>::BITS
                + <B2 as ::scryer_modular_bitfield::Specifier>::BITS)
                % 8usize],
        >;
    }
};

impl UntypedArenaPtr {
    #[doc = r" Returns an instance with zero initialized data."]
    #[allow(clippy::identity_op)]
    pub const fn new() -> Self {
        Self {
            bytes: [0u8; (((0usize
                + <B61 as ::scryer_modular_bitfield::Specifier>::BITS
                + <bool as ::scryer_modular_bitfield::Specifier>::BITS
                + <B2 as ::scryer_modular_bitfield::Specifier>::BITS
                - 1)
                / 8)
                + 1)
                * 8
                / 8usize],
        }
    }
}

impl UntypedArenaPtr {
    #[doc = r" Returns the underlying bits."]
    #[doc = r""]
    #[doc = r" # Layout"]
    #[doc = r""]
    #[doc = r" The returned byte array is layed out in the same way as described"]
    #[doc = r" [here](https://docs.rs/modular-bitfield/#generated-structure)."]
    #[inline]
    #[allow(clippy::identity_op, dead_code)]
    pub const fn into_bytes(
        self,
    ) -> [::core::primitive::u8;
        (((0usize
            + <B61 as ::scryer_modular_bitfield::Specifier>::BITS
            + <bool as ::scryer_modular_bitfield::Specifier>::BITS
            + <B2 as ::scryer_modular_bitfield::Specifier>::BITS
            - 1)
            / 8)
            + 1)
            * 8
            / 8usize] {
        self.bytes
    }
    #[doc = r" Converts the given bytes directly into the bitfield struct."]
    #[inline]
    #[allow(clippy::identity_op, dead_code)]
    pub const fn from_bytes(
        bytes: [::core::primitive::u8;
            (((0usize
                + <B61 as ::scryer_modular_bitfield::Specifier>::BITS
                + <bool as ::scryer_modular_bitfield::Specifier>::BITS
                + <B2 as ::scryer_modular_bitfield::Specifier>::BITS
                - 1)
                / 8)
                + 1)
                * 8
                / 8usize],
    ) -> Self {
        Self { bytes }
    }
}

const _: () = {
    const _: () = {};
    const _: () = {};
    const _: () = {};
};

impl UntypedArenaPtr {
    #[doc = "Returns the value of ptr."]
    #[inline]
    #[allow(unused)]
    fn ptr(&self) -> <B61 as ::scryer_modular_bitfield::Specifier>::InOut {
        self.ptr_or_err()
            .expect("value contains invalid bit pattern for field UntypedArenaPtr.ptr")
    }
    #[doc = "Returns the value of ptr.\n\n#Errors\n\nIf the returned value contains an invalid bit pattern for ptr."]
    #[inline]
    #[allow(dead_code)]
    #[allow(unused)]
    fn ptr_or_err(
        &self,
    ) -> ::core::result::Result<
        <B61 as ::scryer_modular_bitfield::Specifier>::InOut,
        ::scryer_modular_bitfield::error::InvalidBitPattern<
            <B61 as ::scryer_modular_bitfield::Specifier>::Bytes,
        >,
    > {
        let __bf_read: <B61 as ::scryer_modular_bitfield::Specifier>::Bytes =
            { ::scryer_modular_bitfield::private::read_specifier::<B61>(&self.bytes[..], 0usize) };
        <B61 as ::scryer_modular_bitfield::Specifier>::from_bytes(__bf_read)
    }
    #[doc = "Returns a copy of the bitfield with the value of ptr set to the given value.\n\n#Panics\n\nIf the given value is out of bounds for ptr."]
    #[inline]
    #[allow(dead_code)]
    #[allow(unused)]
    fn with_ptr(mut self, new_val: <B61 as ::scryer_modular_bitfield::Specifier>::InOut) -> Self {
        self.set_ptr(new_val);
        self
    }
    #[doc = "Returns a copy of the bitfield with the value of ptr set to the given value.\n\n#Errors\n\nIf the given value is out of bounds for ptr."]
    #[inline]
    #[allow(dead_code)]
    #[allow(unused)]
    fn with_ptr_checked(
        mut self,
        new_val: <B61 as ::scryer_modular_bitfield::Specifier>::InOut,
    ) -> ::core::result::Result<Self, ::scryer_modular_bitfield::error::OutOfBounds> {
        self.set_ptr_checked(new_val)?;
        ::core::result::Result::Ok(self)
    }
    #[doc = "Sets the value of ptr to the given value.\n\n#Panics\n\nIf the given value is out of bounds for ptr."]
    #[inline]
    #[allow(dead_code)]
    #[allow(unused)]
    fn set_ptr(&mut self, new_val: <B61 as ::scryer_modular_bitfield::Specifier>::InOut) {
        self.set_ptr_checked(new_val)
            .expect("value out of bounds for field UntypedArenaPtr.ptr")
    }
    #[doc = "Sets the value of ptr to the given value.\n\n#Errors\n\nIf the given value is out of bounds for ptr."]
    #[inline]
    #[allow(unused)]
    fn set_ptr_checked(
        &mut self,
        new_val: <B61 as ::scryer_modular_bitfield::Specifier>::InOut,
    ) -> ::core::result::Result<(), ::scryer_modular_bitfield::error::OutOfBounds> {
        let __bf_base_bits: ::core::primitive::usize =
            8usize * ::core::mem::size_of::<<B61 as ::scryer_modular_bitfield::Specifier>::Bytes>();
        let __bf_max_value: <B61 as ::scryer_modular_bitfield::Specifier>::Bytes =
            { !0 >> (__bf_base_bits - <B61 as ::scryer_modular_bitfield::Specifier>::BITS) };
        let __bf_spec_bits: ::core::primitive::usize =
            <B61 as ::scryer_modular_bitfield::Specifier>::BITS;
        let __bf_raw_val: <B61 as ::scryer_modular_bitfield::Specifier>::Bytes =
            { <B61 as ::scryer_modular_bitfield::Specifier>::into_bytes(new_val) }?;
        if !(__bf_base_bits == __bf_spec_bits || __bf_raw_val <= __bf_max_value) {
            return ::core::result::Result::Err(::scryer_modular_bitfield::error::OutOfBounds);
        }
        ::scryer_modular_bitfield::private::write_specifier::<B61>(
            &mut self.bytes[..],
            0usize,
            __bf_raw_val,
        );
        ::core::result::Result::Ok(())
    }
    #[doc = "Returns the value of m."]
    #[inline]
    fn m(&self) -> <bool as ::scryer_modular_bitfield::Specifier>::InOut {
        self.m_or_err()
            .expect("value contains invalid bit pattern for field UntypedArenaPtr.m")
    }
    #[doc = "Returns the value of m.\n\n#Errors\n\nIf the returned value contains an invalid bit pattern for m."]
    #[inline]
    #[allow(dead_code)]
    fn m_or_err(
        &self,
    ) -> ::core::result::Result<
        <bool as ::scryer_modular_bitfield::Specifier>::InOut,
        ::scryer_modular_bitfield::error::InvalidBitPattern<
            <bool as ::scryer_modular_bitfield::Specifier>::Bytes,
        >,
    > {
        let __bf_read: <bool as ::scryer_modular_bitfield::Specifier>::Bytes = {
            ::scryer_modular_bitfield::private::read_specifier::<bool>(
                &self.bytes[..],
                0usize + <B61 as ::scryer_modular_bitfield::Specifier>::BITS,
            )
        };
        <bool as ::scryer_modular_bitfield::Specifier>::from_bytes(__bf_read)
    }
    #[doc = "Returns a copy of the bitfield with the value of m set to the given value.\n\n#Panics\n\nIf the given value is out of bounds for m."]
    #[inline]
    #[allow(dead_code)]
    fn with_m(mut self, new_val: <bool as ::scryer_modular_bitfield::Specifier>::InOut) -> Self {
        self.set_m(new_val);
        self
    }
    #[doc = "Returns a copy of the bitfield with the value of m set to the given value.\n\n#Errors\n\nIf the given value is out of bounds for m."]
    #[inline]
    #[allow(dead_code)]
    fn with_m_checked(
        mut self,
        new_val: <bool as ::scryer_modular_bitfield::Specifier>::InOut,
    ) -> ::core::result::Result<Self, ::scryer_modular_bitfield::error::OutOfBounds> {
        self.set_m_checked(new_val)?;
        ::core::result::Result::Ok(self)
    }
    #[doc = "Sets the value of m to the given value.\n\n#Panics\n\nIf the given value is out of bounds for m."]
    #[inline]
    #[allow(dead_code)]
    fn set_m(&mut self, new_val: <bool as ::scryer_modular_bitfield::Specifier>::InOut) {
        self.set_m_checked(new_val)
            .expect("value out of bounds for field UntypedArenaPtr.m")
    }
    #[doc = "Sets the value of m to the given value.\n\n#Errors\n\nIf the given value is out of bounds for m."]
    #[inline]
    fn set_m_checked(
        &mut self,
        new_val: <bool as ::scryer_modular_bitfield::Specifier>::InOut,
    ) -> ::core::result::Result<(), ::scryer_modular_bitfield::error::OutOfBounds> {
        let __bf_base_bits: ::core::primitive::usize = 8usize
            * ::core::mem::size_of::<<bool as ::scryer_modular_bitfield::Specifier>::Bytes>();
        let __bf_max_value: <bool as ::scryer_modular_bitfield::Specifier>::Bytes =
            { !0 >> (__bf_base_bits - <bool as ::scryer_modular_bitfield::Specifier>::BITS) };
        let __bf_spec_bits: ::core::primitive::usize =
            <bool as ::scryer_modular_bitfield::Specifier>::BITS;
        let __bf_raw_val: <bool as ::scryer_modular_bitfield::Specifier>::Bytes =
            { <bool as ::scryer_modular_bitfield::Specifier>::into_bytes(new_val) }?;
        if !(__bf_base_bits == __bf_spec_bits || __bf_raw_val <= __bf_max_value) {
            return ::core::result::Result::Err(::scryer_modular_bitfield::error::OutOfBounds);
        }
        ::scryer_modular_bitfield::private::write_specifier::<bool>(
            &mut self.bytes[..],
            0usize + <B61 as ::scryer_modular_bitfield::Specifier>::BITS,
            __bf_raw_val,
        );
        ::core::result::Result::Ok(())
    }
    #[doc = "Returns the value of padding."]
    #[inline]
    #[allow(unused)]
    fn padding(&self) -> <B2 as ::scryer_modular_bitfield::Specifier>::InOut {
        self.padding_or_err()
            .expect("value contains invalid bit pattern for field UntypedArenaPtr.padding")
    }
    #[doc = "Returns the value of padding.\n\n#Errors\n\nIf the returned value contains an invalid bit pattern for padding."]
    #[inline]
    #[allow(dead_code)]
    #[allow(unused)]
    fn padding_or_err(
        &self,
    ) -> ::core::result::Result<
        <B2 as ::scryer_modular_bitfield::Specifier>::InOut,
        ::scryer_modular_bitfield::error::InvalidBitPattern<
            <B2 as ::scryer_modular_bitfield::Specifier>::Bytes,
        >,
    > {
        let __bf_read: <B2 as ::scryer_modular_bitfield::Specifier>::Bytes = {
            ::scryer_modular_bitfield::private::read_specifier::<B2>(
                &self.bytes[..],
                0usize
                    + <B61 as ::scryer_modular_bitfield::Specifier>::BITS
                    + <bool as ::scryer_modular_bitfield::Specifier>::BITS,
            )
        };
        <B2 as ::scryer_modular_bitfield::Specifier>::from_bytes(__bf_read)
    }
    #[doc = "Returns a copy of the bitfield with the value of padding set to the given value.\n\n#Panics\n\nIf the given value is out of bounds for padding."]
    #[inline]
    #[allow(dead_code)]
    #[allow(unused)]
    fn with_padding(
        mut self,
        new_val: <B2 as ::scryer_modular_bitfield::Specifier>::InOut,
    ) -> Self {
        self.set_padding(new_val);
        self
    }
    #[doc = "Returns a copy of the bitfield with the value of padding set to the given value.\n\n#Errors\n\nIf the given value is out of bounds for padding."]
    #[inline]
    #[allow(dead_code)]
    #[allow(unused)]
    fn with_padding_checked(
        mut self,
        new_val: <B2 as ::scryer_modular_bitfield::Specifier>::InOut,
    ) -> ::core::result::Result<Self, ::scryer_modular_bitfield::error::OutOfBounds> {
        self.set_padding_checked(new_val)?;
        ::core::result::Result::Ok(self)
    }
    #[doc = "Sets the value of padding to the given value.\n\n#Panics\n\nIf the given value is out of bounds for padding."]
    #[inline]
    #[allow(dead_code)]
    #[allow(unused)]
    fn set_padding(&mut self, new_val: <B2 as ::scryer_modular_bitfield::Specifier>::InOut) {
        self.set_padding_checked(new_val)
            .expect("value out of bounds for field UntypedArenaPtr.padding")
    }
    #[doc = "Sets the value of padding to the given value.\n\n#Errors\n\nIf the given value is out of bounds for padding."]
    #[inline]
    #[allow(unused)]
    fn set_padding_checked(
        &mut self,
        new_val: <B2 as ::scryer_modular_bitfield::Specifier>::InOut,
    ) -> ::core::result::Result<(), ::scryer_modular_bitfield::error::OutOfBounds> {
        let __bf_base_bits: ::core::primitive::usize =
            8usize * ::core::mem::size_of::<<B2 as ::scryer_modular_bitfield::Specifier>::Bytes>();
        let __bf_max_value: <B2 as ::scryer_modular_bitfield::Specifier>::Bytes =
            { !0 >> (__bf_base_bits - <B2 as ::scryer_modular_bitfield::Specifier>::BITS) };
        let __bf_spec_bits: ::core::primitive::usize =
            <B2 as ::scryer_modular_bitfield::Specifier>::BITS;
        let __bf_raw_val: <B2 as ::scryer_modular_bitfield::Specifier>::Bytes =
            { <B2 as ::scryer_modular_bitfield::Specifier>::into_bytes(new_val) }?;
        if !(__bf_base_bits == __bf_spec_bits || __bf_raw_val <= __bf_max_value) {
            return ::core::result::Result::Err(::scryer_modular_bitfield::error::OutOfBounds);
        }
        ::scryer_modular_bitfield::private::write_specifier::<B2>(
            &mut self.bytes[..],
            0usize
                + <B61 as ::scryer_modular_bitfield::Specifier>::BITS
                + <bool as ::scryer_modular_bitfield::Specifier>::BITS,
            __bf_raw_val,
        );
        ::core::result::Result::Ok(())
    }
}

#[allow(clippy::identity_op)]
impl ::core::convert::From<::core::primitive::u64> for UntypedArenaPtr
where
    [(); 0usize
        + <B61 as ::scryer_modular_bitfield::Specifier>::BITS
        + <bool as ::scryer_modular_bitfield::Specifier>::BITS
        + <B2 as ::scryer_modular_bitfield::Specifier>::BITS]:
        ::scryer_modular_bitfield::private::IsU64Compatible,
{
    #[inline]
    fn from(__bf_prim: ::core::primitive::u64) -> Self {
        Self {
            bytes: <::core::primitive::u64>::to_le_bytes(__bf_prim),
        }
    }
}
#[allow(clippy::identity_op)]
impl ::core::convert::From<UntypedArenaPtr> for ::core::primitive::u64
where
    [(); 0usize
        + <B61 as ::scryer_modular_bitfield::Specifier>::BITS
        + <bool as ::scryer_modular_bitfield::Specifier>::BITS
        + <B2 as ::scryer_modular_bitfield::Specifier>::BITS]:
        ::scryer_modular_bitfield::private::IsU64Compatible,
{
    #[inline]
    fn from(__bf_bitfield: UntypedArenaPtr) -> Self {
        <Self>::from_le_bytes(__bf_bitfield.bytes)
    }
}

pub fn test() {
    let tmp = UntypedArenaPtr::new();
    eprintln!(
        "[src/lib.rs:{}:{}] UntypedArenaPtr::new() = {:#?}",
        16u32, 5u32, tmp
    );
}

Oddly enough the macro expanded version doesn't produce any unnecessary parenthesis warnings.

$ cargo  check
   Compiling proc-macro2 v1.0.101
   Compiling quote v1.0.41
   Compiling unicode-ident v1.0.19
   Compiling syn v1.0.109
    Checking static_assertions v1.1.0
   Compiling scryer-modular-bitfield-impl v0.11.2
    Checking scryer-modular-bitfield v0.11.4
    Checking repro v0.1.0 (/mnt/f/Git/repro)
warning: method `m` is never used
   --> src/lib.rs:177:8
    |
 99 | impl UntypedArenaPtr {
    | -------------------- method in this implementation
...
177 |     fn m(&self) -> <bool as ::scryer_modular_bitfield::Specifier>::InOut {
    |        ^
    |
    = note: `#[warn(dead_code)]` on by default

warning: `repro` (lib) generated 1 warning
    Finished `dev` profile [unoptimized + debuginfo] target(s) in 6.04s

[Skgland]

The PR introducing the regression in this rollup is #142237: Detect more cases of unused_parens around types

searched nightlies: from nightly-2025-06-23 to nightly-2025-08-02
regressed nightly: nightly-2025-07-04
searched commit range: 6677875...da58c05
regressed commit: 25face9

bisected with cargo-bisect-rustc v0.6.11

Host triple: x86_64-unknown-linux-gnu
Reproduce with:

cargo bisect-rustc --start 1.89.0 --end 1.90.0 

[Skgland]

This appears to be related-to/a-duplicate-of #144378