Enable clippy::missing_const_for_fn (#1883)

* Release 0.9.0-alpha.0

Upgrade our MSRV to 1.65 and remove version detection logic prior to
that version.

* Enable clippy::missing_const_for_fn

While we're here, remove defensive programming against bug in
`Layout::from_size_align` which is no longer needed on our new MSRV.

Author: joshlf

src/byteorder.rs

@@ -967,6 +967,7 @@ module!(network_endian, NetworkEndian, "network-endian");
 module!(native_endian, NativeEndian, "native-endian");
 
 #[cfg(any(test, kani))]
+#[allow(clippy::missing_const_for_fn)]
 mod tests {
     use super::*;
 

src/error.rs

@@ -302,7 +302,7 @@ impl<Src, Dst: ?Sized> AlignmentError<Src, Dst> {
         AlignmentError { src: f(self.src), dst: SendSyncPhantomData::default() }
     }
 
-    pub(crate) fn into<S, V>(self) -> ConvertError<Self, S, V> {
+    pub(crate) const fn into<S, V>(self) -> ConvertError<Self, S, V> {
         ConvertError::Alignment(self)
     }
 
@@ -463,7 +463,7 @@ impl<Src, Dst: ?Sized> SizeError<Src, Dst> {
     }
 
     /// Converts the error into a general [`ConvertError`].
-    pub(crate) fn into<A, V>(self) -> ConvertError<A, Self, V> {
+    pub(crate) const fn into<A, V>(self) -> ConvertError<A, Self, V> {
         ConvertError::Size(self)
     }
 
@@ -595,7 +595,7 @@ impl<Src, Dst: ?Sized + TryFromBytes> ValidityError<Src, Dst> {
     }
 
     /// Converts the error into a general [`ConvertError`].
-    pub(crate) fn into<A, S>(self) -> ConvertError<A, S, Self> {
+    pub(crate) const fn into<A, S>(self) -> ConvertError<A, S, Self> {
         ConvertError::Validity(self)
     }
 
@@ -957,6 +957,7 @@ pub type AlignedTryCastError<Src, Dst: ?Sized + TryFromBytes> =
 pub struct AllocError;
 
 #[cfg(test)]
+#[allow(clippy::missing_const_for_fn)]
 mod tests {
     use super::*;
 

src/lib.rs

@@ -248,6 +248,7 @@
     clippy::double_must_use,
     clippy::get_unwrap,
     clippy::indexing_slicing,
+    clippy::missing_const_for_fn,
     clippy::missing_inline_in_public_items,
     clippy::missing_safety_doc,
     clippy::must_use_candidate,
@@ -3030,17 +3031,6 @@ pub unsafe trait FromZeros: TryFromBytes {
         };
 
         let align = Self::LAYOUT.align.get();
-        // On stable Rust versions <= 1.64.0, `Layout::from_size_align` has a
-        // bug in which sufficiently-large allocations (those which, when
-        // rounded up to the alignment, overflow `isize`) are not rejected,
-        // which can cause undefined behavior. See #64 for details.
-        //
-        // TODO(#67): Once our MSRV is > 1.64.0, remove this assertion.
-        #[allow(clippy::as_conversions)]
-        let max_alloc = (isize::MAX as usize).saturating_sub(align);
-        if size > max_alloc {
-            return Err(AllocError);
-        }
 
         // TODO(https://github.com/rust-lang/rust/issues/55724): Use
         // `Layout::repeat` once it's stabilized.
@@ -3055,7 +3045,6 @@ pub unsafe trait FromZeros: TryFromBytes {
                 None => return Err(AllocError),
             }
         } else {
-            let align = Self::LAYOUT.align.get();
             // We use `transmute` instead of an `as` cast since Miri (with
             // strict provenance enabled) notices and complains that an `as`
             // cast creates a pointer with no provenance. Miri isn't smart
@@ -5398,7 +5387,11 @@ mod alloc_support {
 pub use alloc_support::*;
 
 #[cfg(test)]
-#[allow(clippy::assertions_on_result_states, clippy::unreadable_literal)]
+#[allow(
+    clippy::assertions_on_result_states,
+    clippy::unreadable_literal,
+    clippy::missing_const_for_fn
+)]
 mod tests {
     use static_assertions::assert_impl_all;
 

src/pointer/ptr.rs

@@ -103,7 +103,7 @@ mod def {
         ///    [`I::Alignment`](invariant::Alignment).
         /// 8. `ptr` conforms to the validity invariant of
         ///    [`I::Validity`](invariant::Validity).
-        pub(super) unsafe fn new(ptr: NonNull<T>) -> Ptr<'a, T, I> {
+        pub(super) const unsafe fn new(ptr: NonNull<T>) -> Ptr<'a, T, I> {
             // SAFETY: The caller has promised to satisfy all safety invariants
             // of `Ptr`.
             Self { ptr, _invariants: PhantomData }
@@ -114,7 +114,7 @@ mod def {
         /// Note that this method does not consume `self`. The caller should
         /// watch out for `unsafe` code which uses the returned `NonNull` in a
         /// way that violates the safety invariants of `self`.
-        pub(crate) fn as_non_null(&self) -> NonNull<T> {
+        pub(crate) const fn as_non_null(&self) -> NonNull<T> {
             self.ptr
         }
     }
@@ -717,7 +717,7 @@ mod _transitions {
         /// # Safety
         ///
         /// The caller promises that `self` satisfies the invariants `H`.
-        unsafe fn assume_invariants<H: Invariants>(self) -> Ptr<'a, T, H> {
+        const unsafe fn assume_invariants<H: Invariants>(self) -> Ptr<'a, T, H> {
             // SAFETY: The caller has promised to satisfy all parameterized
             // invariants of `Ptr`. `Ptr`'s other invariants are satisfied
             // by-contract by the source `Ptr`.
@@ -726,7 +726,7 @@ mod _transitions {
 
         /// Helps the type system unify two distinct invariant types which are
         /// actually the same.
-        pub(crate) fn unify_invariants<
+        pub(crate) const fn unify_invariants<
             H: Invariants<Aliasing = I::Aliasing, Alignment = I::Alignment, Validity = I::Validity>,
         >(
             self,
@@ -743,7 +743,7 @@ mod _transitions {
         /// The caller promises that `self` satisfies the aliasing requirement
         /// of `A`.
         #[inline]
-        pub(crate) unsafe fn assume_aliasing<A: Aliasing>(
+        pub(crate) const unsafe fn assume_aliasing<A: Aliasing>(
             self,
         ) -> Ptr<'a, T, (A, I::Alignment, I::Validity)> {
             // SAFETY: The caller promises that `self` satisfies the aliasing
@@ -760,7 +760,7 @@ mod _transitions {
         ///
         /// [`Exclusive`]: invariant::Exclusive
         #[inline]
-        pub(crate) unsafe fn assume_exclusive(
+        pub(crate) const unsafe fn assume_exclusive(
             self,
         ) -> Ptr<'a, T, (Exclusive, I::Alignment, I::Validity)> {
             // SAFETY: The caller promises that `self` satisfies the aliasing
@@ -776,7 +776,7 @@ mod _transitions {
         /// The caller promises that `self`'s referent conforms to the alignment
         /// invariant of `T` if required by `A`.
         #[inline]
-        pub(crate) unsafe fn assume_alignment<A: Alignment>(
+        pub(crate) const unsafe fn assume_alignment<A: Alignment>(
             self,
         ) -> Ptr<'a, T, (I::Aliasing, A, I::Validity)> {
             // SAFETY: The caller promises that `self`'s referent is
@@ -804,7 +804,7 @@ mod _transitions {
         #[inline]
         // TODO(#859): Reconsider the name of this method before making it
         // public.
-        pub(crate) fn bikeshed_recall_aligned(
+        pub(crate) const fn bikeshed_recall_aligned(
             self,
         ) -> Ptr<'a, T, (I::Aliasing, Aligned, I::Validity)>
         where
@@ -825,7 +825,7 @@ mod _transitions {
         #[doc(hidden)]
         #[must_use]
         #[inline]
-        pub unsafe fn assume_validity<V: Validity>(
+        pub const unsafe fn assume_validity<V: Validity>(
             self,
         ) -> Ptr<'a, T, (I::Aliasing, I::Alignment, V)> {
             // SAFETY: The caller promises that `self`'s referent conforms to
@@ -842,7 +842,7 @@ mod _transitions {
         #[doc(hidden)]
         #[must_use]
         #[inline]
-        pub unsafe fn assume_initialized(
+        pub const unsafe fn assume_initialized(
             self,
         ) -> Ptr<'a, T, (I::Aliasing, I::Alignment, Initialized)> {
             // SAFETY: The caller has promised to uphold the safety
@@ -859,7 +859,7 @@ mod _transitions {
         #[doc(hidden)]
         #[must_use]
         #[inline]
-        pub unsafe fn assume_valid(self) -> Ptr<'a, T, (I::Aliasing, I::Alignment, Valid)> {
+        pub const unsafe fn assume_valid(self) -> Ptr<'a, T, (I::Aliasing, I::Alignment, Valid)> {
             // SAFETY: The caller has promised to uphold the safety
             // preconditions.
             unsafe { self.assume_validity::<Valid>() }
@@ -871,7 +871,7 @@ mod _transitions {
         #[inline]
         // TODO(#859): Reconsider the name of this method before making it
         // public.
-        pub fn bikeshed_recall_valid(self) -> Ptr<'a, T, (I::Aliasing, I::Alignment, Valid)>
+        pub const fn bikeshed_recall_valid(self) -> Ptr<'a, T, (I::Aliasing, I::Alignment, Valid)>
         where
             T: crate::FromBytes,
             I: Invariants<Validity = Initialized>,
@@ -921,7 +921,7 @@ mod _transitions {
         #[doc(hidden)]
         #[must_use]
         #[inline]
-        pub fn forget_exclusive(self) -> Ptr<'a, T, (Shared, I::Alignment, I::Validity)>
+        pub const fn forget_exclusive(self) -> Ptr<'a, T, (Shared, I::Alignment, I::Validity)>
         where
             I::Aliasing: AtLeast<Shared>,
         {
@@ -933,7 +933,7 @@ mod _transitions {
         #[doc(hidden)]
         #[must_use]
         #[inline]
-        pub fn forget_aligned(self) -> Ptr<'a, T, (I::Aliasing, Any, I::Validity)> {
+        pub const fn forget_aligned(self) -> Ptr<'a, T, (I::Aliasing, Any, I::Validity)> {
             // SAFETY: `Any` is less restrictive than `Aligned`.
             unsafe { self.assume_invariants() }
         }
@@ -1641,6 +1641,7 @@ mod _project {
 }
 
 #[cfg(test)]
+#[allow(clippy::missing_const_for_fn)]
 mod tests {
     use core::mem::{self, MaybeUninit};
 

src/ref.rs

@@ -75,7 +75,7 @@ mod def {
         /// [`deref`]: core::ops::Deref::deref
         /// [`deref_mut`]: core::ops::DerefMut::deref_mut
         /// [`into`]: core::convert::Into::into
-        pub(crate) unsafe fn new_unchecked(bytes: B) -> Ref<B, T> {
+        pub(crate) const unsafe fn new_unchecked(bytes: B) -> Ref<B, T> {
             // INVARIANTS: The caller has promised that `bytes`'s referent is
             // validly-aligned and has a valid size.
             Ref(bytes, PhantomData)

src/util/macros.rs

@@ -255,7 +255,7 @@ macro_rules! impl_for_transparent_wrapper {
                 impl_for_transparent_wrapper!(@define_is_transparent_wrapper $trait);
 
                 #[cfg_attr(coverage_nightly, coverage(off))]
-                fn f<I: Invariants, $($tyvar $(: $(? $optbound +)* $($bound +)*)?)?>() {
+                const fn f<I: Invariants, $($tyvar $(: $(? $optbound +)* $($bound +)*)?)?>() {
                     is_transparent_wrapper::<I, $ty>();
                 }
             }
@@ -327,7 +327,7 @@ macro_rules! impl_for_transparent_wrapper {
     };
     (@define_is_transparent_wrapper $trait:ident, $variance:ident) => {
         #[cfg_attr(coverage_nightly, coverage(off))]
-        fn is_transparent_wrapper<I: Invariants, W: TransparentWrapper<I, $variance = Covariant> + ?Sized>()
+        const fn is_transparent_wrapper<I: Invariants, W: TransparentWrapper<I, $variance = Covariant> + ?Sized>()
         where
             W::Inner: $trait,
         {}

src/util/mod.rs

@@ -756,6 +756,7 @@ pub(crate) mod polyfills {
 }
 
 #[cfg(test)]
+#[allow(clippy::missing_const_for_fn)]
 pub(crate) mod testutil {
     use crate::*;
 
@@ -845,6 +846,7 @@ pub(crate) mod testutil {
 }
 
 #[cfg(test)]
+#[allow(clippy::missing_const_for_fn)]
 mod tests {
     use super::*;
 

src/wrappers.rs

@@ -393,9 +393,8 @@ impl<T> Unalign<T> {
 
 impl<T: Copy> Unalign<T> {
     /// Gets a copy of the inner `T`.
-    // TODO(https://github.com/rust-lang/rust/issues/57349): Make this `const`.
     #[inline(always)]
-    pub fn get(&self) -> T {
+    pub const fn get(&self) -> T {
         let Unalign(val) = *self;
         val
     }