Enforce even more library clippy lints in CI

library/alloc/src/boxed.rs

@@ -813,7 +813,6 @@ impl<T: ?Sized + CloneToUninit> Box<T> {
     /// ```
     #[unstable(feature = "clone_from_ref", issue = "149075")]
     //#[unstable(feature = "allocator_api", issue = "32838")]
-    #[must_use]
     #[inline]
     pub fn try_clone_from_ref(src: &T) -> Result<Box<T>, AllocError> {
         Box::try_clone_from_ref_in(src, Global)
@@ -865,7 +864,6 @@ impl<T: ?Sized + CloneToUninit, A: Allocator> Box<T, A> {
     /// ```
     #[unstable(feature = "clone_from_ref", issue = "149075")]
     //#[unstable(feature = "allocator_api", issue = "32838")]
-    #[must_use]
     #[inline]
     pub fn try_clone_from_ref_in(src: &T, alloc: A) -> Result<Box<T, A>, AllocError> {
         struct DeallocDropGuard<'a, A: Allocator>(Layout, &'a A, NonNull<u8>);
@@ -1161,7 +1159,6 @@ impl<T, A: Allocator> Box<[T], A> {
     /// ```
     #[unstable(feature = "alloc_slice_into_array", issue = "148082")]
     #[inline]
-    #[must_use]
     pub fn into_array<const N: usize>(self) -> Result<Box<[T; N], A>, Self> {
         if self.len() == N {
             let (ptr, alloc) = Self::into_raw_with_allocator(self);

library/alloc/src/bstr.rs

@@ -42,7 +42,7 @@ use crate::vec::Vec;
 /// showing invalid UTF-8 as hex escapes or the Unicode replacement character, respectively.
 #[unstable(feature = "bstr", issue = "134915")]
 #[repr(transparent)]
-#[derive(Clone)]
+#[derive(Clone, Default)]
 #[doc(alias = "BString")]
 pub struct ByteString(pub Vec<u8>);
 
@@ -187,13 +187,6 @@ impl BorrowMut<ByteStr> for ByteString {
 
 // `impl BorrowMut<ByteStr> for Vec<u8>` omitted to avoid inference failures
 
-#[unstable(feature = "bstr", issue = "134915")]
-impl Default for ByteString {
-    fn default() -> Self {
-        ByteString(Vec::new())
-    }
-}
-
 // Omitted due to inference failures
 //
 // #[unstable(feature = "bstr", issue = "134915")]

library/alloc/src/collections/btree/map.rs

@@ -670,7 +670,7 @@ impl<K, V, A: Allocator + Clone> BTreeMap<K, V, A> {
     pub fn clear(&mut self) {
         // avoid moving the allocator
         drop(BTreeMap {
-            root: mem::replace(&mut self.root, None),
+            root: self.root.take(),
             length: mem::replace(&mut self.length, 0),
             alloc: self.alloc.clone(),
             _marker: PhantomData,

library/alloc/src/collections/btree/set.rs

@@ -901,7 +901,7 @@ impl<T, A: Allocator + Clone> BTreeSet<T, A> {
     where
         T: Ord,
     {
-        self.map.insert(value, SetValZST::default()).is_none()
+        self.map.insert(value, SetValZST).is_none()
     }
 
     /// Adds a value to the set, replacing the existing element, if any, that is
@@ -1483,7 +1483,7 @@ impl<T: Ord> FromIterator<T> for BTreeSet<T> {
 
 impl<T: Ord, A: Allocator + Clone> BTreeSet<T, A> {
     fn from_sorted_iter<I: Iterator<Item = T>>(iter: I, alloc: A) -> BTreeSet<T, A> {
-        let iter = iter.map(|k| (k, SetValZST::default()));
+        let iter = iter.map(|k| (k, SetValZST));
         let map = BTreeMap::bulk_build_from_sorted_iter(iter, alloc);
         BTreeSet { map }
     }

library/alloc/src/collections/linked_list.rs

@@ -369,7 +369,7 @@ impl<T, A: Allocator> LinkedList<T, A> {
 
             // Fix the head ptr of the second part
             self.head = Some(split_node);
-            self.len = self.len - at;
+            self.len -= at;
 
             first_part
         } else {

library/alloc/src/collections/vec_deque/mod.rs

@@ -2049,6 +2049,7 @@ impl<T, A: Allocator> VecDeque<T, A> {
     /// assert!(deque.is_empty());
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
+    #[expect(clippy::manual_clear, reason = "implements clear")]
     #[inline]
     pub fn clear(&mut self) {
         self.truncate(0);
@@ -3312,7 +3313,7 @@ impl<T, A: Allocator> VecDeque<T, A> {
         F: FnMut(&'a T) -> Ordering,
     {
         let (front, back) = self.as_slices();
-        let cmp_back = back.first().map(|elem| f(elem));
+        let cmp_back = back.first().map(&mut f);
 
         if let Some(Ordering::Equal) = cmp_back {
             Ok(front.len())
@@ -3423,7 +3424,7 @@ impl<T, A: Allocator> VecDeque<T, A> {
     {
         let (front, back) = self.as_slices();
 
-        if let Some(true) = back.first().map(|v| pred(v)) {
+        if let Some(true) = back.first().map(&mut pred) {
             back.partition_point(pred) + front.len()
         } else {
             front.partition_point(pred)

library/alloc/src/io/buffered/bufreader.rs

@@ -153,7 +153,7 @@ impl<R: Read + ?Sized> BufReader<R> {
             let new = self.buf.read_more(&mut self.inner)?;
             if new == 0 {
                 // end of file, no more bytes to read
-                return Ok(&self.buf.buffer()[..]);
+                return Ok(self.buf.buffer());
             }
             debug_assert_eq!(self.buf.pos(), 0);
         }

library/alloc/src/lib.rs

@@ -59,6 +59,7 @@
 #![allow(unused_features)]
 #![allow(incomplete_features)]
 #![allow(unused_attributes)]
+#![expect(clippy::partialeq_ne_impl, reason = "we need to implement ne for a lot of alloc types")]
 #![stable(feature = "alloc", since = "1.36.0")]
 #![doc(
     html_playground_url = "https://play.rust-lang.org/",

library/alloc/src/rc.rs

@@ -1257,7 +1257,6 @@ impl<T, A: Allocator> Rc<[T], A> {
     /// ```
     #[unstable(feature = "alloc_slice_into_array", issue = "148082")]
     #[inline]
-    #[must_use]
     pub fn into_array<const N: usize>(self) -> Result<Rc<[T; N], A>, Self> {
         if self.len() == N {
             let (ptr, alloc) = Self::into_raw_with_allocator(self);

library/alloc/src/sync.rs

@@ -1416,7 +1416,6 @@ impl<T, A: Allocator> Arc<[T], A> {
     /// ```
     #[unstable(feature = "alloc_slice_into_array", issue = "148082")]
     #[inline]
-    #[must_use]
     pub fn into_array<const N: usize>(self) -> Result<Arc<[T; N], A>, Self> {
         if self.len() == N {
             let (ptr, alloc) = Self::into_raw_with_allocator(self);

library/alloc/src/vec/mod.rs

@@ -1749,7 +1749,6 @@ impl<T, A: Allocator> Vec<T, A> {
     /// ```
     #[cfg(not(no_global_oom_handling))]
     #[unstable(feature = "alloc_slice_into_array", issue = "148082")]
-    #[must_use]
     pub fn into_array<const N: usize>(self) -> Result<Box<[T; N], A>, Self> {
         if self.len() == N {
             // SAFETY: `Box::into_array` is guaranteed to return `Ok` if the

library/core/src/ascii/ascii_char.rs

@@ -635,7 +635,7 @@ impl AsciiChar {
     pub const fn eq_ignore_case(self, other: Self) -> bool {
         // FIXME(const-hack) `arg.to_u8().to_ascii_lowercase()` -> `arg.to_lowercase()`
         // once `PartialEq` is const for `Self`.
-        self.to_u8().to_ascii_lowercase() == other.to_u8().to_ascii_lowercase()
+        self.to_u8().eq_ignore_ascii_case(&other.to_u8())
     }
 
     /// Converts this value to its upper case equivalent in-place.

library/core/src/char/methods.rs

@@ -1,5 +1,7 @@
 //! impl char {}
 
+#![expect(clippy::manual_is_ascii_check, reason = "this module implements various is_ascii checks")]
+
 use super::*;
 use crate::panic::const_panic;
 use crate::slice;
@@ -343,6 +345,7 @@ impl char {
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
     #[rustc_const_stable(feature = "const_char_classify", since = "1.87.0")]
+    #[expect(clippy::to_digit_is_some, reason = "implements is_digit")]
     #[inline]
     pub const fn is_digit(self, radix: u32) -> bool {
         self.to_digit(radix).is_some()
@@ -1985,6 +1988,7 @@ impl char {
     /// [to_ascii_lowercase]: #method.to_ascii_lowercase
     #[stable(feature = "ascii_methods_on_intrinsics", since = "1.23.0")]
     #[rustc_const_stable(feature = "const_ascii_methods_on_intrinsics", since = "1.52.0")]
+    #[expect(clippy::manual_ignore_case_cmp, reason = "implements eq_ignore_ascii_case")]
     #[inline]
     pub const fn eq_ignore_ascii_case(&self, other: &char) -> bool {
         self.to_ascii_lowercase() == other.to_ascii_lowercase()

library/core/src/field.rs

@@ -78,7 +78,7 @@ impl<T: ?Sized, const VARIANT: u32, const FIELD: u32> Default
     for FieldRepresentingType<T, VARIANT, FIELD>
 {
     fn default() -> Self {
-        Self { _phantom: PhantomData::default() }
+        Self { _phantom: PhantomData }
     }
 }
 

library/core/src/hash/mod.rs

@@ -691,6 +691,7 @@ pub trait BuildHasher {
     /// );
     /// ```
     #[stable(feature = "build_hasher_simple_hash_one", since = "1.71.0")]
+    #[expect(clippy::manual_hash_one, reason = "implements hash_one")]
     fn hash_one<T: Hash>(&self, x: T) -> u64
     where
         Self: Sized,

library/core/src/intrinsics/mod.rs

@@ -2915,14 +2915,9 @@ pub const fn contract_check_ensures<C: Fn(&Ret) -> bool + Copy, Ret>(
             // Do nothing
             ret
         } else {
-            match cond {
-                crate::option::Option::Some(cond) => {
-                    if !cond(&ret) {
-                        // Emit no unwind panic in case this was a safety requirement.
-                        crate::panicking::panic_nounwind("failed ensures check");
-                    }
-                },
-                crate::option::Option::None => {},
+            if let crate::option::Option::Some(cond) = cond && !cond(&ret) {
+                // Emit no unwind panic in case this was a safety requirement.
+                crate::panicking::panic_nounwind("failed ensures check");
             }
             ret
         }

library/core/src/io/error.rs

@@ -234,7 +234,6 @@ impl Error {
 
     #[doc(hidden)]
     #[unstable(feature = "core_io_internals", reason = "exposed only for libstd", issue = "none")]
-    #[must_use]
     #[inline]
     pub fn into_custom_owner(self) -> result::Result<CustomOwner, Self> {
         if matches!(self.repr.data(), ErrorData::Custom(..)) {

library/core/src/io/seek.rs

@@ -142,6 +142,7 @@ pub trait Seek {
     /// }
     /// ```
     #[stable(feature = "seek_convenience", since = "1.51.0")]
+    #[expect(clippy::seek_from_current, reason = "implements stream_position")]
     fn stream_position(&mut self) -> Result<u64> {
         self.seek(SeekFrom::Current(0))
     }

library/core/src/lib.rs

@@ -187,6 +187,10 @@
 #![feature(x86_amx_intrinsics)]
 // tidy-alphabetical-end
 
+// tidy-alphabetical-start
+#![expect(clippy::partialeq_ne_impl, reason = "we need to implement ne for a lot of core types")]
+// tidy-alphabetical-end
+
 // allow using `core::` in intra-doc links
 #[allow(unused_extern_crates)]
 extern crate self as core;
@@ -360,7 +364,9 @@ pub mod primitive;
     unsafe_op_in_unsafe_fn,
     ambiguous_glob_reexports,
     deprecated_in_future,
-    unreachable_pub
+    unreachable_pub,
+    // FIXME: stdach is a submodule so clippy lints should be fixed (and ideally enforced) there
+    clippy::all,
 )]
 #[allow(rustdoc::bare_urls)]
 mod core_arch;

library/core/src/num/f128.rs

@@ -10,6 +10,7 @@
 //! defined directly on the `f128` type.
 
 #![unstable(feature = "f128", issue = "116909")]
+#![expect(clippy::approx_constant, reason = "this module defines f128 constants")]
 
 use crate::convert::{FloatToFloat, FloatToInt};
 use crate::num::FpCategory;
@@ -1499,6 +1500,7 @@ impl f128 {
     #[inline]
     #[unstable(feature = "f128", issue = "116909")]
     #[must_use = "method returns a new number and does not mutate the original value"]
+    #[expect(clippy::neg_cmp_op_on_partial_ord, reason = "NaN is also invalid")]
     pub const fn clamp(mut self, min: f128, max: f128) -> f128 {
         const_assert!(
             min <= max,
@@ -1543,8 +1545,9 @@ impl f128 {
     #[inline]
     #[unstable(feature = "clamp_magnitude", issue = "148519")]
     #[must_use = "this returns the clamped value and does not modify the original"]
+    #[expect(clippy::neg_cmp_op_on_partial_ord, reason = "NaN is also invalid")]
     pub fn clamp_magnitude(self, limit: f128) -> f128 {
-        assert!(limit >= 0.0, "limit must be non-negative");
+        assert!(limit >= 0.0, "limit must be non-negative and not NaN");
         let limit = limit.abs(); // Canonicalises -0.0 to 0.0
         self.clamp(-limit, limit)
     }

library/core/src/num/f16.rs

@@ -10,6 +10,7 @@
 //! defined directly on the `f16` type.
 
 #![unstable(feature = "f16", issue = "116909")]
+#![expect(clippy::approx_constant, reason = "this module defines f16 constants")]
 
 use crate::convert::{FloatToFloat, FloatToInt};
 use crate::num::FpCategory;
@@ -1485,6 +1486,7 @@ impl f16 {
     #[inline]
     #[unstable(feature = "f16", issue = "116909")]
     #[must_use = "method returns a new number and does not mutate the original value"]
+    #[expect(clippy::neg_cmp_op_on_partial_ord, reason = "NaN is also invalid")]
     pub const fn clamp(mut self, min: f16, max: f16) -> f16 {
         const_assert!(
             min <= max,
@@ -1529,8 +1531,9 @@ impl f16 {
     #[inline]
     #[unstable(feature = "clamp_magnitude", issue = "148519")]
     #[must_use = "this returns the clamped value and does not modify the original"]
+    #[expect(clippy::neg_cmp_op_on_partial_ord, reason = "NaN is also invalid")]
     pub fn clamp_magnitude(self, limit: f16) -> f16 {
-        assert!(limit >= 0.0, "limit must be non-negative");
+        assert!(limit >= 0.0, "limit must be non-negative and not NaN");
         let limit = limit.abs(); // Canonicalises -0.0 to 0.0
         self.clamp(-limit, limit)
     }

library/core/src/num/f32.rs

@@ -10,6 +10,7 @@
 //! defined directly on the `f32` type.
 
 #![stable(feature = "rust1", since = "1.0.0")]
+#![expect(clippy::approx_constant, reason = "this module defines f32 constants")]
 
 use crate::convert::{FloatToFloat, FloatToInt};
 use crate::num::FpCategory;
@@ -438,22 +439,22 @@ impl f32 {
     /// [`MANTISSA_DIGITS`]: f32::MANTISSA_DIGITS
     #[stable(feature = "assoc_int_consts", since = "1.43.0")]
     #[rustc_diagnostic_item = "f32_epsilon"]
-    pub const EPSILON: f32 = 1.19209290e-07_f32;
+    pub const EPSILON: f32 = 1.1920929e-07_f32;
 
     /// Smallest finite `f32` value.
     ///
     /// Equal to −[`MAX`].
     ///
     /// [`MAX`]: f32::MAX
     #[stable(feature = "assoc_int_consts", since = "1.43.0")]
-    pub const MIN: f32 = -3.40282347e+38_f32;
+    pub const MIN: f32 = -3.4028235e+38_f32;
     /// Smallest positive normal `f32` value.
     ///
     /// Equal to 2<sup>[`MIN_EXP`]&nbsp;&minus;&nbsp;1</sup>.
     ///
     /// [`MIN_EXP`]: f32::MIN_EXP
     #[stable(feature = "assoc_int_consts", since = "1.43.0")]
-    pub const MIN_POSITIVE: f32 = 1.17549435e-38_f32;
+    pub const MIN_POSITIVE: f32 = 1.1754944e-38_f32;
     /// Largest finite `f32` value.
     ///
     /// Equal to
@@ -462,7 +463,7 @@ impl f32 {
     /// [`MANTISSA_DIGITS`]: f32::MANTISSA_DIGITS
     /// [`MAX_EXP`]: f32::MAX_EXP
     #[stable(feature = "assoc_int_consts", since = "1.43.0")]
-    pub const MAX: f32 = 3.40282347e+38_f32;
+    pub const MAX: f32 = 3.4028235e+38_f32;
 
     /// One greater than the minimum possible *normal* power of 2 exponent
     /// for a significand bounded by 1 ≤ x < 2 (i.e. the IEEE definition).
@@ -1659,6 +1660,7 @@ impl f32 {
     #[stable(feature = "clamp", since = "1.50.0")]
     #[rustc_const_stable(feature = "const_float_methods", since = "1.85.0")]
     #[inline]
+    #[expect(clippy::neg_cmp_op_on_partial_ord, reason = "Nan is also invalid")]
     pub const fn clamp(mut self, min: f32, max: f32) -> f32 {
         const_assert!(
             min <= max,
@@ -1700,8 +1702,9 @@ impl f32 {
     #[must_use = "this returns the clamped value and does not modify the original"]
     #[unstable(feature = "clamp_magnitude", issue = "148519")]
     #[inline]
+    #[expect(clippy::neg_cmp_op_on_partial_ord, reason = "NaN is also invalid")]
     pub fn clamp_magnitude(self, limit: f32) -> f32 {
-        assert!(limit >= 0.0, "limit must be non-negative");
+        assert!(limit >= 0.0, "limit must be non-negative and not NaN");
         let limit = limit.abs(); // Canonicalises -0.0 to 0.0
         self.clamp(-limit, limit)
     }