Fix clippy issues (#681)

# Objective

Fix the clippy errors in the CI

# Solution

- Run `cargo +stable clippy --workspace --no-deps --all-features
--all-targets --fix -- -D warnings` multiple times
- Add `#[allow(clippy::large_stack_arrays)]`
https://github.com/valence-rs/valence/blob/8f3f84d557dacddd7faddb2ad724185ecee2e482/crates/valence_generated/build/block.rs#L695
- Replace every triple slash comment in `valence_generated` and
`valence_entity` with `#[doc]`
- Replace eliding `'a` lifetimes in `stresser.rs` with a single `'_`

benches/packet.rs

···
     let encoder = PacketEncoder::new();
 
     const BLOCKS_AND_BIOMES: [u8; 2000] = [0x80; 2000];
-    const SKY_LIGHT_ARRAYS: [FixedArray<u8, 2048>; 26] = [FixedArray([0xff; 2048]); 26];
+    static SKY_LIGHT_ARRAYS: [FixedArray<u8, 2048>; 26] = [FixedArray([0xff; 2048]); 26];
 
     let chunk_data_packet = ChunkDataS2c {
         pos: ChunkPos::new(123, 456),

crates/java_string/src/cesu8.rs

···
 
 #[inline]
 fn dec_surrogate(second: u8, third: u8) -> u32 {
-    0xd000 | u32::from(second & CONT_MASK) << 6 | u32::from(third & CONT_MASK)
+    0xd000 | (u32::from(second & CONT_MASK) << 6) | u32::from(third & CONT_MASK)
 }
 
 #[inline]

crates/java_string/src/char.rs

···
                 *a = code as u8;
             }
             (2, [a, b, ..]) => {
-                *a = (code >> 6 & 0x1f) as u8 | TAG_TWO_B;
+                *a = ((code >> 6) & 0x1f) as u8 | TAG_TWO_B;
                 *b = (code & 0x3f) as u8 | TAG_CONT;
             }
             (3, [a, b, c, ..]) => {
-                *a = (code >> 12 & 0x0f) as u8 | TAG_THREE_B;
-                *b = (code >> 6 & 0x3f) as u8 | TAG_CONT;
+                *a = ((code >> 12) & 0x0f) as u8 | TAG_THREE_B;
+                *b = ((code >> 6) & 0x3f) as u8 | TAG_CONT;
                 *c = (code & 0x3f) as u8 | TAG_CONT;
             }
             (4, [a, b, c, d, ..]) => {
-                *a = (code >> 18 & 0x07) as u8 | TAG_FOUR_B;
-                *b = (code >> 12 & 0x3f) as u8 | TAG_CONT;
-                *c = (code >> 6 & 0x3f) as u8 | TAG_CONT;
+                *a = ((code >> 18) & 0x07) as u8 | TAG_FOUR_B;
+                *b = ((code >> 12) & 0x3f) as u8 | TAG_CONT;
+                *c = ((code >> 6) & 0x3f) as u8 | TAG_CONT;
                 *d = (code & 0x3f) as u8 | TAG_CONT;
             }
             _ => panic!(

crates/java_string/src/iter.rs

···
 }
 delegate!(Iterator for EscapeDebug<'a> => char);
 delegate!(FusedIterator for EscapeDebug<'a>);
-impl<'a> Display for EscapeDebug<'a> {
+impl Display for EscapeDebug<'_> {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         self.clone().try_for_each(|c| f.write_char(c))
     }
···
 }
 delegate!(Iterator for EscapeDefault<'a> => char);
 delegate!(FusedIterator for EscapeDefault<'a>);
-impl<'a> Display for EscapeDefault<'a> {
+impl Display for EscapeDefault<'_> {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         self.clone().try_for_each(|c| f.write_char(c))
     }
···
 }
 delegate!(Iterator for EscapeUnicode<'a> => char);
 delegate!(FusedIterator for EscapeUnicode<'a>);
-impl<'a> Display for EscapeUnicode<'a> {
+impl Display for EscapeUnicode<'_> {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         self.clone().try_for_each(|c| f.write_char(c))
     }
···
     pub(crate) inner: slice::Iter<'a, u8>,
 }
 
-impl<'a> Iterator for Chars<'a> {
+impl Iterator for Chars<'_> {
     type Item = JavaCodePoint;
 
     #[inline]
···
     #[inline]
     fn size_hint(&self) -> (usize, Option<usize>) {
         let len = self.inner.len();
-        // `(len + 3)` can't overflow, because we know that the `slice::Iter`
-        // belongs to a slice in memory which has a maximum length of
-        // `isize::MAX` (that's well below `usize::MAX`).
-        ((len + 3) / 4, Some(len))
+        (len.div_ceil(4), Some(len))
     }
 
     #[inline]
···
     }
 }
 
-impl<'a> DoubleEndedIterator for Chars<'a> {
+impl DoubleEndedIterator for Chars<'_> {
     #[inline]
     fn next_back(&mut self) -> Option<Self::Item> {
         // SAFETY: `JavaStr` invariant says `self.inner` is a semi-valid UTF-8 string
···
     pub(crate) inner: Chars<'a>,
 }
 
-impl<'a> Iterator for CharIndices<'a> {
+impl Iterator for CharIndices<'_> {
     type Item = (usize, JavaCodePoint);
 
     #[inline]
···
     }
 }
 
-impl<'a> DoubleEndedIterator for CharIndices<'a> {
+impl DoubleEndedIterator for CharIndices<'_> {
     #[inline]
     fn next_back(&mut self) -> Option<(usize, JavaCodePoint)> {
         self.inner.next_back().map(|ch| {
···
     }
 }
 
-impl<'a, P> DoubleEndedIterator for Matches<'a, P>
+impl<P> DoubleEndedIterator for Matches<'_, P>
 where
     P: JavaStrPattern,
 {
···
     }
 }
 
-impl<'a, P> DoubleEndedIterator for RMatches<'a, P>
+impl<P> DoubleEndedIterator for RMatches<'_, P>
 where
     P: JavaStrPattern,
 {
···
     }
 }
 
-impl<'a, P> DoubleEndedIterator for MatchIndices<'a, P>
+impl<P> DoubleEndedIterator for MatchIndices<'_, P>
 where
     P: JavaStrPattern,
 {
···
     }
 }
 
-impl<'a, P> DoubleEndedIterator for RMatchIndices<'a, P>
+impl<P> DoubleEndedIterator for RMatchIndices<'_, P>
 where
     P: JavaStrPattern,
 {
···
     }
 }
 
-impl<'a, P> DoubleEndedIterator for Split<'a, P>
+impl<P> DoubleEndedIterator for Split<'_, P>
 where
     P: JavaStrPattern,
 {
···
     }
 }
 
-impl<'a, P> FusedIterator for Split<'a, P> where P: JavaStrPattern {}
+impl<P> FusedIterator for Split<'_, P> where P: JavaStrPattern {}
 
 #[derive(Clone, Debug)]
 pub struct RSplit<'a, P> {
···
     }
 }
 
-impl<'a, P> DoubleEndedIterator for RSplit<'a, P>
+impl<P> DoubleEndedIterator for RSplit<'_, P>
 where
     P: JavaStrPattern,
 {
···
     }
 }
 
-impl<'a, P> FusedIterator for RSplit<'a, P> where P: JavaStrPattern {}
+impl<P> FusedIterator for RSplit<'_, P> where P: JavaStrPattern {}
 
 #[derive(Clone, Debug)]
 pub struct SplitTerminator<'a, P> {
···
     }
 }
 
-impl<'a, P> DoubleEndedIterator for SplitTerminator<'a, P>
+impl<P> DoubleEndedIterator for SplitTerminator<'_, P>
 where
     P: JavaStrPattern,
 {
···
     }
 }
 
-impl<'a, P> FusedIterator for SplitTerminator<'a, P> where P: JavaStrPattern {}
+impl<P> FusedIterator for SplitTerminator<'_, P> where P: JavaStrPattern {}
 
 #[derive(Clone, Debug)]
 pub struct RSplitTerminator<'a, P> {
···
     }
 }
 
-impl<'a, P> DoubleEndedIterator for RSplitTerminator<'a, P>
+impl<P> DoubleEndedIterator for RSplitTerminator<'_, P>
 where
     P: JavaStrPattern,
 {
···
     }
 }
 
-impl<'a, P> FusedIterator for RSplitTerminator<'a, P> where P: JavaStrPattern {}
+impl<P> FusedIterator for RSplitTerminator<'_, P> where P: JavaStrPattern {}
 
 #[derive(Clone, Debug)]
 pub struct SplitInclusive<'a, P> {
···
     }
 }
 
-impl<'a, P> DoubleEndedIterator for SplitInclusive<'a, P>
+impl<P> DoubleEndedIterator for SplitInclusive<'_, P>
 where
     P: JavaStrPattern,
 {
···
     }
 }
 
-impl<'a, P> FusedIterator for SplitInclusive<'a, P> where P: JavaStrPattern {}
+impl<P> FusedIterator for SplitInclusive<'_, P> where P: JavaStrPattern {}
 
 #[derive(Clone, Debug)]
 pub struct SplitN<'a, P> {
···
     }
 }
 
-impl<'a, P> FusedIterator for SplitN<'a, P> where P: JavaStrPattern {}
+impl<P> FusedIterator for SplitN<'_, P> where P: JavaStrPattern {}
 
 #[derive(Clone, Debug)]
 pub struct RSplitN<'a, P> {
···
     }
 }
 
-impl<'a, P> FusedIterator for RSplitN<'a, P> where P: JavaStrPattern {}
+impl<P> FusedIterator for RSplitN<'_, P> where P: JavaStrPattern {}
 
 #[derive(Clone, Debug)]
 pub struct SplitAsciiWhitespace<'a> {

crates/java_string/src/owned.rs

···
             del_bytes: usize,
         }
 
-        impl<'a> Drop for SetLenOnDrop<'a> {
+        impl Drop for SetLenOnDrop<'_> {
             #[inline]
             fn drop(&mut self) {
                 let new_len = self.idx - self.del_bytes;
···
     }
 }
 
-impl<'a> From<JavaString> for Cow<'a, JavaStr> {
+impl From<JavaString> for Cow<'_, JavaStr> {
     #[inline]
     fn from(value: JavaString) -> Self {
         Cow::Owned(value)
···
     }
 }
 
-impl<'a> PartialEq<JavaString> for &'a str {
+impl PartialEq<JavaString> for &str {
     #[inline]
     fn eq(&self, other: &JavaString) -> bool {
         *self == other
···
     }
 }
 
-impl<'a> PartialEq<JavaString> for Cow<'a, str> {
+impl PartialEq<JavaString> for Cow<'_, str> {
     #[inline]
     fn eq(&self, other: &JavaString) -> bool {
         self == &other[..]
···
     }
 }
 
-impl<'a> PartialEq<JavaString> for Cow<'a, JavaStr> {
+impl PartialEq<JavaString> for Cow<'_, JavaStr> {
     #[inline]
     fn eq(&self, other: &JavaString) -> bool {
         self == &other[..]

crates/java_string/src/serde.rs

···
 
 struct JavaCodePointVisitor;
 
-impl<'de> Visitor<'de> for JavaCodePointVisitor {
+impl Visitor<'_> for JavaCodePointVisitor {
     type Value = JavaCodePoint;
 
     fn expecting(&self, formatter: &mut Formatter) -> std::fmt::Result {

crates/java_string/src/slice.rs

···
     }
 }
 
-impl<'a> AddAssign<&JavaStr> for Cow<'a, JavaStr> {
+impl AddAssign<&JavaStr> for Cow<'_, JavaStr> {
     #[inline]
     fn add_assign(&mut self, rhs: &JavaStr) {
         if !rhs.is_empty() {
···
     }
 }
 
-impl<'a, 'b> PartialEq<&'b JavaStr> for Cow<'a, str> {
+impl<'b> PartialEq<&'b JavaStr> for Cow<'_, str> {
     #[inline]
     fn eq(&self, other: &&'b JavaStr) -> bool {
         self == *other
     }
 }
 
-impl<'a, 'b> PartialEq<&'b JavaStr> for Cow<'a, JavaStr> {
+impl<'b> PartialEq<&'b JavaStr> for Cow<'_, JavaStr> {
     #[inline]
     fn eq(&self, other: &&'b JavaStr) -> bool {
         self == *other
     }
 }
 
-impl<'a, 'b> PartialEq<Cow<'a, str>> for &'b JavaStr {
+impl<'a> PartialEq<Cow<'a, str>> for &JavaStr {
     #[inline]
     fn eq(&self, other: &Cow<'a, str>) -> bool {
         *self == other
···
     }
 }
 
-impl<'a, 'b> PartialEq<Cow<'a, JavaStr>> for &'b JavaStr {
+impl<'a> PartialEq<Cow<'a, JavaStr>> for &JavaStr {
     #[inline]
     fn eq(&self, other: &Cow<'a, JavaStr>) -> bool {
         *self == other
···
     }
 }
 
-impl<'a> PartialEq<String> for &'a JavaStr {
+impl PartialEq<String> for &JavaStr {
     #[inline]
     fn eq(&self, other: &String) -> bool {
         *self == other
···
     }
 }
 
-impl<'a> PartialEq<JavaString> for &'a JavaStr {
+impl PartialEq<JavaString> for &JavaStr {
     #[inline]
     fn eq(&self, other: &JavaString) -> bool {
         *self == other
···
     }
 }
 
-impl<'a> PartialEq<JavaStr> for Cow<'a, str> {
+impl PartialEq<JavaStr> for Cow<'_, str> {
     #[inline]
     fn eq(&self, other: &JavaStr) -> bool {
         match self {
···
     }
 }
 
-impl<'a> PartialEq<JavaStr> for Cow<'a, JavaStr> {
+impl PartialEq<JavaStr> for Cow<'_, JavaStr> {
     #[inline]
     fn eq(&self, other: &JavaStr) -> bool {
         match self {
···
     }
 }
 
-impl<'a> PartialEq<JavaStr> for &'a str {
+impl PartialEq<JavaStr> for &str {
     #[inline]
     fn eq(&self, other: &JavaStr) -> bool {
         self.as_bytes() == &other.inner
···
     }
 }
 
-impl<'a> PartialEq<JavaStr> for &'a JavaStr {
+impl PartialEq<JavaStr> for &JavaStr {
     #[inline]
     fn eq(&self, other: &JavaStr) -> bool {
         self.inner == other.inner

crates/java_string/src/validations.rs

···
         // so the iterator must produce a value here.
         let z = unsafe { *bytes.next().unwrap_unchecked() };
         let y_z = utf8_acc_cont_byte((y & CONT_MASK).into(), z);
-        ch = init << 12 | y_z;
+        ch = (init << 12) | y_z;
         if x >= 0xf0 {
             // [x y z w] case
             // use only the lower 3 bits of `init`
             // SAFETY: `bytes` produces an UTF-8-like string,
             // so the iterator must produce a value here.
             let w = unsafe { *bytes.next().unwrap_unchecked() };
-            ch = (init & 7) << 18 | utf8_acc_cont_byte(y_z, w);
+            ch = ((init & 7) << 18) | utf8_acc_cont_byte(y_z, w);
         }
     }
 

crates/valence_advancement/src/lib.rs

···
     criteria_query: Query<'w, 's, &'static AdvancementCriteria>,
 }
 
-impl<'w, 's> UpdateAdvancementCachedBytesQuery<'w, 's> {
+impl UpdateAdvancementCachedBytesQuery<'_, '_> {
     fn write(
         &self,
         a_identifier: &Advancement,
···
     queries: &'a SingleAdvancementUpdateQuery<'w, 's>,
 }
 
-impl<'w, 's, 'a> Encode for AdvancementUpdateEncodeS2c<'w, 's, 'a> {
+impl Encode for AdvancementUpdateEncodeS2c<'_, '_, '_> {
     fn encode(&self, w: impl Write) -> anyhow::Result<()> {
         let SingleAdvancementUpdateQuery {
             advancement_bytes: advancement_bytes_query,
···
     }
 }
 
-impl<'w, 's, 'a> Packet for AdvancementUpdateEncodeS2c<'w, 's, 'a> {
+impl Packet for AdvancementUpdateEncodeS2c<'_, '_, '_> {
     const ID: i32 = packet_id::ADVANCEMENT_UPDATE_S2C;
     const NAME: &'static str = "AdvancementUpdateEncodeS2c";
     const SIDE: PacketSide = PacketSide::Clientbound;

crates/valence_anvil/src/lib.rs

···
         }
         let compress_buf = compress_cursor.into_inner();
 
-        // additional 5 bytes for exact chunk size + compression type, then add
-        // SECTOR_SIZE - 1 for rounding up
-        let num_sectors_needed = (compress_buf.len() + 5 + SECTOR_SIZE - 1) / SECTOR_SIZE;
+        // additional 5 bytes for exact chunk size + compression type
+        let num_sectors_needed = (compress_buf.len() + 5).div_ceil(SECTOR_SIZE);
         let (start_sector, num_sectors) = if num_sectors_needed >= 256 {
             if options.skip_oversized_chunks {
                 return Err(RegionError::OversizedChunk);

crates/valence_entity/build.rs

···
     }
 
     systems.extend([quote! {
-        /// Special case for `living::Absorption`.
-        /// Updates the `AbsorptionAmount` component of the player entity.
+        #[doc = "Special case for `living::Absorption`."]
+        #[doc = "Updates the `AbsorptionAmount` component of the player entity."]
         fn update_living_and_player_absorption(
             mut query: Query<(&living::Absorption, &mut player::AbsorptionAmount), Changed<living::Absorption>>
         ) {
···
             }
         }
 
-        /// Special case for `living::Attributes`.
+        #[doc = "Special case for `living::Attributes`."]
         fn update_living_attributes(
             mut query: Query<(
                 &mut attributes::TrackedEntityAttributes,
···
 
         #modules
 
-        /// Identifies the type of an entity.
-        /// As a component, the entity kind should not be modified.
+        #[doc = "Identifies the type of an entity."]
+        #[doc = "As a component, the entity kind should not be modified."]
         #[derive(Component, Copy, Clone, PartialEq, Eq, PartialOrd, Ord, Hash, Default, ::derive_more::Deref)]
         pub struct EntityKind(i32);
 

crates/valence_entity/src/active_status_effects.rs

···
     pub fn no_effect(&self, effect: StatusEffect) -> bool {
         self.current_effects
             .get(&effect)
-            .map_or(true, |effects| effects.is_empty())
+            .is_none_or(|effects| effects.is_empty())
     }
 
     /// Returns true if there is an effect of the given type.
     pub fn has_effect(&self, effect: StatusEffect) -> bool {
         self.current_effects
             .get(&effect)
-            .map_or(false, |effects| !effects.is_empty())
+            .is_some_and(|effects| !effects.is_empty())
     }
 
     /// Returns true if there are no effects.
···
         self.status_effect().instant()
             || self
                 .remaining_duration()
-                .map_or(false, |duration| duration <= 0)
+                .is_some_and(|duration| duration <= 0)
     }
 }
 

crates/valence_entity/src/hitbox.rs

···
             EntityKind::GOAT => {
                 if pose_query
                     .get(entity)
-                    .map_or(false, |v| v.0 == Pose::LongJumping)
+                    .is_ok_and(|v| v.0 == Pose::LongJumping)
                 {
                     [0.63, 0.91, 0.63]
                 } else {

crates/valence_generated/build/attributes.rs

···
     }
 
     Ok(quote!(
-        /// An attribute modifier operation.
+        #[doc = "An attribute modifier operation."]
         #[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
         pub enum EntityAttributeOperation {
-            /// Adds the modifier to the base value.
+            #[doc = "Adds the modifier to the base value."]
             Add,
-            /// Multiplies the modifier with the base value.
+            #[doc = "Multiplies the modifier with the base value."]
             MultiplyBase,
-            /// Multiplies the modifier with the total value.
+            #[doc = "Multiplies the modifier with the total value."]
             MultiplyTotal,
         }
 
         impl EntityAttributeOperation {
-            /// Converts from a raw [`u8`].
+            #[doc = "Converts from a raw [`u8`]."]
             pub fn from_raw(raw: u8) -> Option<Self> {
                 match raw {
                     0 => Some(Self::Add),
···
                 }
             }
 
-            /// Converts to a raw [`u8`].
+            #[doc = "Converts to a raw [`u8`]."]
             pub fn to_raw(self) -> u8 {
                 match self {
                     Self::Add => 0,

crates/valence_generated/build/block.rs

···
     Ok(quote! {
         use valence_math::{Aabb, DVec3};
 
-        /// Represents the state of a block. This does not include block entity data such as
-        /// the text on a sign, the design on a banner, or the content of a spawner.
+        #[doc = "Represents the state of a block. This does not include block entity data such as"]
+        #[doc = "the text on a sign, the design on a banner, or the content of a spawner."]
         #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Default, Hash)]
         pub struct BlockState(u16);
 
         impl BlockState {
-            /// Returns the default block state for a given block type.
+            #[doc = "Returns the default block state for a given block type."]
             pub const fn from_kind(kind: BlockKind) -> Self {
                 match kind {
                     #kind_to_state_arms
                 }
             }
 
-            /// Constructs a block state from a raw block state ID.
-            ///
-            /// If the given ID is invalid, `None` is returned.
+            #[doc = "Constructs a block state from a raw block state ID."]
+            #[doc = ""]
+            #[doc = "If the given ID is invalid, `None` is returned."]
             pub const fn from_raw(id: u16) -> Option<Self> {
                 if id <= #max_state_id {
                     Some(Self(id))
···
                 }
             }
 
-            /// Returns the [`BlockKind`] of this block state.
+            #[doc = "Returns the [`BlockKind`] of this block state."]
             pub const fn to_kind(self) -> BlockKind {
                 match self.0 {
                     #state_to_kind_arms
···
                 }
             }
 
-            /// Converts this block state to its underlying raw block state ID.
-            ///
-            /// The original block state can be recovered with [`BlockState::from_raw`].
+            #[doc = "Converts this block state to its underlying raw block state ID."]
+            #[doc = ""]
+            #[doc = "The original block state can be recovered with [`BlockState::from_raw`]."]
             pub const fn to_raw(self) -> u16 {
                 self.0
             }
 
-            /// Returns the maximum block state ID.
+            #[doc = "Returns the maximum block state ID."]
             pub const fn max_raw() -> u16 {
                 #max_state_id
             }
 
-            /// Returns the wall variant of the block state.
-            ///
-            /// If the given block state doesn't have a wall variant, `None` is returned.
+            #[doc = "Returns the wall variant of the block state."]
+            #[doc = ""]
+            #[doc = "If the given block state doesn't have a wall variant, `None` is returned."]
             pub const fn wall_block_id(self) -> Option<Self> {
                 match self {
                     #state_to_wall_variant_arms
···
                 }
             }
 
-            /// Gets the value of the property with the given name from this block.
-            ///
-            /// If this block does not have the property, then `None` is returned.
+            #[doc = "Gets the value of the property with the given name from this block."]
+            #[doc = ""]
+            #[doc = "If this block does not have the property, then `None` is returned."]
             pub const fn get(self, name: PropName) -> Option<PropValue> {
                 match self.to_kind() {
                     #get_arms
···
                 }
             }
 
-            /// Sets the value of a property on this block, returning the modified block.
-            ///
-            /// If this block does not have the given property or the property value is invalid,
-            /// then the original block is returned unchanged.
+            #[doc = "Sets the value of a property on this block, returning the modified block."]
+            #[doc = ""]
+            #[doc = "If this block does not have the given property or the property value is invalid,"]
+            #[doc = "then the original block is returned unchanged."]
             #[must_use]
             pub const fn set(self, name: PropName, val: PropValue) -> Self {
                 match self.to_kind() {
···
                 }
             }
 
-            /// If this block is `air`, `cave_air` or `void_air`.
+            #[doc = "If this block is `air`, `cave_air` or `void_air`."]
             pub const fn is_air(self) -> bool {
                 matches!(
                     self,
···
 
             // TODO: is_solid
 
-            /// If this block is water or lava.
+            #[doc = "If this block is water or lava."]
             pub const fn is_liquid(self) -> bool {
                 matches!(self.to_kind(), BlockKind::Water | BlockKind::Lava)
             }
···
                 }
             }
 
+            #[allow(clippy::large_stack_arrays)]
             const SHAPES: [Aabb; #shape_count] = [
                 #(#shapes,)*
             ];
···
             #default_block_states
         }
 
-        /// An enumeration of all block kinds.
+        #[doc = "An enumeration of all block kinds."]
         #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
         pub enum BlockKind {
             #(#block_kind_variants,)*
         }
 
         impl BlockKind {
-            /// Construct a block kind from its snake_case name.
-            ///
-            /// Returns `None` if the name is invalid.
+            #[doc = "Construct a block kind from its snake_case name."]
+            #[doc = ""]
+            #[doc = "Returns `None` if the name is invalid."]
             pub fn from_str(name: &str) -> Option<Self> {
                 match name {
                     #block_kind_from_str_arms
···
                 }
             }
 
-            /// Get the snake_case name of this block kind.
+            #[doc = "Get the snake_case name of this block kind."]
             pub const fn to_str(self) -> &'static str {
                 match self {
                     #block_kind_to_str_arms
                 }
             }
 
-            /// Returns the default block state for a given block kind.
+            #[doc = "Returns the default block state for a given block kind."]
             pub const fn to_state(self) -> BlockState {
                 BlockState::from_kind(self)
             }
 
-            /// Returns a slice of all properties this block kind has.
+            #[doc = "Returns a slice of all properties this block kind has."]
             pub const fn props(self) -> &'static [PropName] {
                 match self {
                     #block_kind_props_arms
···
                 }
             }
 
-            /// Converts a block kind to its corresponding item kind.
-            ///
-            /// [`ItemKind::Air`] is used to indicate the absence of an item.
+            #[doc = "Converts a block kind to its corresponding item kind."]
+            #[doc = ""]
+            #[doc = "[`ItemKind::Air`] is used to indicate the absence of an item."]
             pub const fn to_item_kind(self) -> ItemKind {
                 let id = match self {
                     #block_kind_to_item_kind_arms
···
                 }
             }
 
-            /// Constructs a block kind from an item kind.
-            ///
-            /// If the given item does not have a corresponding block, `None` is returned.
+            #[doc = "Constructs a block kind from an item kind."]
+            #[doc = ""]
+            #[doc = "If the given item does not have a corresponding block, `None` is returned."]
             pub const fn from_item_kind(item: ItemKind) -> Option<Self> {
                 // The "default" blocks are ordered before the other variants.
                 // For instance, `torch` comes before `wall_torch` so this match
···
                 }
             }
 
-            /// Constructs a block kind from a raw block kind ID.
-            ///
-            /// If the given ID is invalid, `None` is returned.
+            #[doc = "Constructs a block kind from a raw block kind ID."]
+            #[doc = ""]
+            #[doc = "If the given ID is invalid, `None` is returned."]
             pub const fn from_raw(id: u16) -> Option<Self> {
                 match id {
                     #block_kind_from_raw_arms
···
                 }
             }
 
-            /// Converts this block kind to its underlying raw block state ID.
-            ///
-            /// The original block kind can be recovered with [`BlockKind::from_raw`].
+            #[doc = "Converts this block kind to its underlying raw block state ID."]
+            #[doc = ""]
+            #[doc = "The original block kind can be recovered with [`BlockKind::from_raw`]."]
             pub const fn to_raw(self) -> u16 {
                 self as u16
             }
 
-            /// An array of all block kinds.
+            #[doc = "An array of all block kinds."]
             pub const ALL: [Self; #block_kind_count] = [#(Self::#block_kind_variants,)*];
         }
 
-        /// The default block kind is `air`.
+        #[doc = "The default block kind is `air`."]
         impl Default for BlockKind {
             fn default() -> Self {
                 Self::Air
             }
         }
 
-        /// Contains all possible block state property names.
-        ///
-        /// For example, `waterlogged`, `facing`, and `half` are all property names.
+        #[doc = "Contains all possible block state property names."]
+        #[doc = ""]
+        #[doc = "For example, `waterlogged`, `facing`, and `half` are all property names."]
         #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
         pub enum PropName {
             #(#prop_name_variants,)*
         }
 
         impl PropName {
-            /// Construct a property name from its snake_case name.
-            ///
-            /// Returns `None` if the given name is not valid.
+            #[doc = "Construct a property name from its snake_case name."]
+            #[doc = ""]
+            #[doc = "Returns `None` if the given name is not valid."]
             pub fn from_str(name: &str) -> Option<Self> {
                 // TODO: match on str in const fn.
                 match name {
···
                 }
             }
 
-            /// Get the snake_case name of this property name.
+            #[doc = "Get the snake_case name of this property name."]
             pub const fn to_str(self) -> &'static str {
                 match self {
                     #prop_name_to_str_arms
                 }
             }
 
-            /// An array of all property names.
+            #[doc = "An array of all property names."]
             pub const ALL: [Self; #prop_name_count] = [#(Self::#prop_name_variants,)*];
         }
 
-        /// Contains all possible values that a block property might have.
-        ///
-        /// For example, `upper`, `true`, and `2` are all property values.
+        #[doc = "Contains all possible values that a block property might have."]
+        #[doc = ""]
+        #[doc = "For example, `upper`, `true`, and `2` are all property values."]
         #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
         pub enum PropValue {
             #(#prop_value_variants,)*
         }
 
         impl PropValue {
-            /// Construct a property value from its snake_case name.
-            ///
-            /// Returns `None` if the given name is not valid.
+            #[doc = "Construct a property value from its snake_case name."]
+            #[doc = ""]
+            #[doc = "Returns `None` if the given name is not valid."]
             pub fn from_str(name: &str) -> Option<Self> {
                 match name {
                     #prop_value_from_str_arms
···
                 }
             }
 
-            /// Get the snake_case name of this property value.
+            #[doc = "Get the snake_case name of this property value."]
             pub const fn to_str(self) -> &'static str {
                 match self {
                     #prop_value_to_str_arms
                 }
             }
 
-            /// Converts a `u16` into a numeric property value.
-            /// Returns `None` if the given number does not have a
-            /// corresponding property value.
+            #[doc = "Converts a `u16` into a numeric property value."]
+            #[doc = "Returns `None` if the given number does not have a"]
+            #[doc = "corresponding property value."]
             pub const fn from_u16(n: u16) -> Option<Self> {
                 match n {
                     #prop_value_from_u16_arms
···
                 }
             }
 
-            /// Converts this property value into a `u16` if it is numeric.
-            /// Returns `None` otherwise.
+            #[doc = "Converts this property value into a `u16` if it is numeric."]
+            #[doc = "Returns `None` otherwise."]
             pub const fn to_u16(self) -> Option<u16> {
                 match self {
                     #prop_value_to_u16_arms
···
                 }
             }
 
-            /// Converts a `bool` to a `True` or `False` property value.
+            #[doc = "Converts a `bool` to a `True` or `False` property value."]
             pub const fn from_bool(b: bool) -> Self {
                 if b {
                     Self::True
···
                 }
             }
 
-            /// Converts a `True` or `False` property value to a `bool`.
-            ///
-            /// Returns `None` if this property value is not `True` or `False`
+            #[doc = "Converts a `True` or `False` property value to a `bool`."]
+            #[doc = ""]
+            #[doc = "Returns `None` if this property value is not `True` or `False`"]
             pub const fn to_bool(self) -> Option<bool> {
                 match self {
                     Self::True => Some(true),
···
                 }
             }
 
-            /// An array of all property values.
+            #[doc = "An array of all property values."]
             pub const ALL: [Self; #prop_value_count] = [#(Self::#prop_value_variants,)*];
         }
 

crates/valence_generated/build/chunk_view.rs

···
     let array_len = MAX_VIEW_DIST as usize + 1;
 
     quote! {
-        /// The maximum view distance for a `ChunkView`.
+        #[doc = "The maximum view distance for a `ChunkView`."]
         pub const MAX_VIEW_DIST: u8 = #MAX_VIEW_DIST;
 
         pub const EXTRA_VIEW_RADIUS: i32 = #EXTRA_VIEW_RADIUS;

crates/valence_generated/build/item.rs

···
         .collect::<TokenStream>();
 
     Ok(quote! {
-        /// Represents an item from the game
+        #[doc = "Represents an item from the game"]
         #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug, Default)]
         #[repr(u16)]
         pub enum ItemKind {
···
             #(#item_kind_variants,)*
         }
 
-        /// Contains food information about an item.
-        ///
-        /// Only food items have a food component.
+        #[doc = "Contains food information about an item."]
+        #[doc = ""]
+        #[doc = "Only food items have a food component."]
         #[derive(Clone, Copy, PartialEq, PartialOrd, Debug)]
         pub struct FoodComponent {
             pub hunger: u16,
···
         }
 
         impl ItemKind {
-            /// Constructs a item kind from a raw item ID.
-            ///
-            /// If the given ID is invalid, `None` is returned.
+            #[doc = "Constructs a item kind from a raw item ID."]
+            #[doc = ""]
+            #[doc = "If the given ID is invalid, `None` is returned."]
             pub const fn from_raw(id: u16) -> Option<Self> {
                 match id {
                     #item_kind_from_raw_id_arms
···
                 }
             }
 
-            /// Gets the raw item ID from the item kind
+            #[doc = "Gets the raw item ID from the item kind"]
             pub const fn to_raw(self) -> u16 {
                 match self {
                     #item_kind_to_raw_id_arms
                 }
             }
 
-            /// Construct an item kind for its snake_case name.
-            ///
-            /// Returns `None` if the name is invalid.
+            #[doc = "Construct an item kind for its snake_case name."]
+            #[doc = ""]
+            #[doc = "Returns `None` if the name is invalid."]
             #[allow(clippy::should_implement_trait)]
             pub fn from_str(name: &str) -> Option<ItemKind> {
                 match name {
···
                 }
             }
 
-            /// Gets the snake_case name of this item kind.
+            #[doc = "Gets the snake_case name of this item kind."]
             pub const fn to_str(self) -> &'static str {
                 match self {
                     #item_kind_to_str_arms
                 }
             }
 
-            /// Gets the translation key of this item kind.
+            #[doc = "Gets the translation key of this item kind."]
             pub const fn translation_key(self) -> &'static str {
                 match self {
                     #item_kind_to_translation_key_arms
                 }
             }
 
-            /// Returns the maximum stack count.
+            #[doc = "Returns the maximum stack count."]
             pub const fn max_stack(self) -> i8 {
                 match self {
                     #item_kind_to_max_stack_arms
                 }
             }
 
-            /// Returns a food component which stores hunger, saturation etc.
-            ///
-            /// If the item kind can't be eaten, `None` will be returned.
+            #[doc = "Returns a food component which stores hunger, saturation etc."]
+            #[doc = ""]
+            #[doc = "If the item kind can't be eaten, `None` will be returned."]
             pub const fn food_component(self) -> Option<FoodComponent> {
                 match self {
                     #item_kind_to_food_component_arms
···
                 }
             }
 
-            /// Returns the maximum durability before the item will break.
-            ///
-            /// If the item doesn't have durability, `0` is returned.
+            #[doc = "Returns the maximum durability before the item will break."]
+            #[doc = ""]
+            #[doc = "If the item doesn't have durability, `0` is returned."]
             pub const fn max_durability(self) -> u16 {
                 match self {
                     #item_kind_to_max_durability_arms
···
                 }
             }
 
-            /// Returns the enchantability of the item kind.
-            ///
-            /// If the item doesn't have durability, `0` is returned.
+            #[doc = "Returns the enchantability of the item kind."]
+            #[doc = ""]
+            #[doc = "If the item doesn't have durability, `0` is returned."]
             pub const fn enchantability(self) -> u8 {
                 match self {
                     #item_kind_to_enchantability_arms
···
                 }
             }
 
-            /// Returns if the item can survive in fire/lava.
+            #[doc = "Returns if the item can survive in fire/lava."]
             pub const fn fireproof(self) -> bool {
                 #[allow(clippy::match_like_matches_macro)]
                 match self {
···
             }
 
             /*
-            /// Constructs an item kind from a block kind.
-            ///
-            /// [`ItemKind::Air`] is used to indicate the absence of an item.
+            #[doc = "Constructs an item kind from a block kind."]
+            #[doc = ""]
+            #[doc = "[`ItemKind::Air`] is used to indicate the absence of an item."]
             pub const fn from_block_kind(kind: BlockKind) -> Self {
                 kind.to_item_kind()
             }
 
-            /// Constructs a block kind from an item kind.
-            ///
-            /// If the given item kind doesn't have a corresponding block kind, `None` is returned.
+            #[doc = "Constructs a block kind from an item kind."]
+            #[doc = ""]
+            #[doc = "If the given item kind doesn't have a corresponding block kind, `None` is returned."]
             pub const fn to_block_kind(self) -> Option<BlockKind> {
                 BlockKind::from_item_kind(self)
             }*/
 
-            /// An array of all item kinds.
+            #[doc = "An array of all item kinds."]
             pub const ALL: [Self; #item_kind_count] = [#(Self::#item_kind_variants,)*];
         }
     })

crates/valence_generated/build/sound.rs

···
     Ok(quote! {
         use valence_ident::{Ident, ident};
 
-        /// Represents a sound from the game
+        #[doc = "Represents a sound from the game"]
         #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
         pub enum Sound {
             #(#sound_variants,)*
         }
 
         impl Sound {
-            /// Constructs a sound from a raw item ID.
-            ///
-            /// If the given ID is invalid, `None` is returned.
+            #[doc = "Constructs a sound from a raw item ID."]
+            #[doc = ""]
+            #[doc = "If the given ID is invalid, `None` is returned."]
             pub const fn from_raw(id: u16) -> Option<Self> {
                 match id {
                     #sound_from_raw_id_arms
···
                 }
             }
 
-            /// Gets the raw sound ID from the sound
+            #[doc = "Gets the raw sound ID from the sound"]
             pub const fn to_raw(self) -> u16 {
                 match self {
                     #sound_to_raw_id_arms
                 }
             }
 
-            /// Construct a sound from its snake_case name.
-            ///
-            /// Returns `None` if the name is invalid.
+            #[doc = "Construct a sound from its snake_case name."]
+            #[doc = ""]
+            #[doc = "Returns `None` if the name is invalid."]
             pub fn from_ident(id: Ident<&str>) -> Option<Self> {
                 match id.as_str() {
                     #sound_from_ident_arms
···
                 }
             }
 
-            /// Gets the identifier of this sound.
+            #[doc = "Gets the identifier of this sound."]
             pub const fn to_ident(self) -> Ident<&'static str> {
                 match self {
                     #sound_to_ident_arms
                 }
             }
 
-            /// An array of all sounds.
+            #[doc = "An array of all sounds."]
             pub const ALL: [Self; #sound_count] = [#(Self::#sound_variants,)*];
         }
     })

crates/valence_generated/build/status_effects.rs

···
         use valence_ident::{Ident, ident};
         use super::attributes::{EntityAttribute, EntityAttributeOperation};
 
-        /// Represents an attribute modifier.
+        #[doc = "Represents an attribute modifier."]
         #[derive(Debug, Clone, Copy, PartialEq)]
         pub struct AttributeModifier {
-            /// The attribute that this modifier modifies.
+            #[doc = "The attribute that this modifier modifies."]
             pub attribute: EntityAttribute,
-            /// The operation that this modifier applies.
+            #[doc = "The operation that this modifier applies."]
             pub operation: EntityAttributeOperation,
-            /// The value of this modifier.
+            #[doc = "The value of this modifier."]
             pub value: f64,
-            /// The UUID of this modifier.
+            #[doc = "The UUID of this modifier."]
             pub uuid: Uuid,
         }
 
-        /// Represents a status effect category
+        #[doc = "Represents a status effect category"]
         #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
         pub enum StatusEffectCategory {
             Beneficial,
···
             Neutral,
         }
 
-        /// Represents a status effect from the game
+        #[doc = "Represents a status effect from the game"]
         #[derive(Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash, Debug)]
         pub enum StatusEffect {
             #(#effect_variants,)*
         }
 
         impl StatusEffect {
-            /// Constructs a effect from a raw item ID.
-            ///
-            /// If the given ID is invalid, `None` is returned.
+            #[doc = "Constructs a effect from a raw item ID."]
+            #[doc = ""]
+            #[doc = "If the given ID is invalid, `None` is returned."]
             pub const fn from_raw(id: u16) -> Option<Self> {
                 match id {
                     #effect_from_raw_id_arms
···
                 }
             }
 
-            /// Gets the raw effect ID from the effect
+            #[doc = "Gets the raw effect ID from the effect"]
             pub const fn to_raw(self) -> u16 {
                 match self {
                     #effect_to_raw_id_arms
                 }
             }
 
-            /// Construct a effect from its snake_case name.
-            ///
-            /// Returns `None` if the name is invalid.
+            #[doc = "Construct a effect from its snake_case name."]
+            #[doc = ""]
+            #[doc = "Returns `None` if the name is invalid."]
             pub fn from_ident(id: Ident<&str>) -> Option<Self> {
                 match id.as_str() {
                     #effect_from_ident_arms
···
                 }
             }
 
-            /// Gets the identifier of this effect.
+            #[doc = "Gets the identifier of this effect."]
             pub const fn to_ident(self) -> Ident<&'static str> {
                 match self {
                     #effect_to_ident_arms
                 }
             }
 
-            /// Gets the name of this effect.
-            /// Same as [`StatusEffect::to_ident`], but doesn't take ownership.
+            #[doc = "Gets the name of this effect."]
+            #[doc = "Same as [`StatusEffect::to_ident`], but doesn't take ownership."]
             pub const fn name(&self) -> Ident<&'static str> {
                 match self {
                     #effect_to_ident_arms
                 }
             }
 
-            /// Gets the translation key of this effect.
+            #[doc = "Gets the translation key of this effect."]
             pub const fn translation_key(&self) -> &'static str {
                 match self {
                     #effect_to_translation_key_arms
                 }
             }
 
-            /// Gets the category of this effect.
+            #[doc = "Gets the category of this effect."]
             pub const fn category(&self) -> StatusEffectCategory {
                 match self {
                     #effect_to_category_arms
                 }
             }
 
-            /// Gets the color of this effect.
+            #[doc = "Gets the color of this effect."]
             pub const fn color(&self) -> u32 {
                 match self {
                     #effect_to_color_arms
                 }
             }
 
-            /// Gets whether this effect is instant.
+            #[doc = "Gets whether this effect is instant."]
             pub const fn instant(&self) -> bool {
                 match self {
                     #effect_to_instant_arms
                 }
             }
 
-            /// Gets the attribute modifiers of this effect.
+            #[doc = "Gets the attribute modifiers of this effect."]
             pub fn attribute_modifiers(&self) -> Vec<AttributeModifier> {
                 match self {
                     #effect_to_attribute_modifiers_arms
···
                 }
             }
 
-            /// An array of all effects.
+            #[doc = "An array of all effects."]
             pub const ALL: [Self; #effect_count] = [#(Self::#effect_variants,)*];
         }
     })

crates/valence_ident/src/lib.rs

···
     }
 }
 
-impl<'a> Ident<Cow<'a, str>> {
+impl Ident<Cow<'_, str>> {
     pub fn borrowed(&self) -> Ident<Cow<str>> {
         Ident::new_unchecked(Cow::Borrowed(self.as_str()))
     }
···
     }
 }
 
-impl<'a> From<Ident<String>> for Ident<Cow<'a, str>> {
+impl From<Ident<String>> for Ident<Cow<'_, str>> {
     fn from(value: Ident<String>) -> Self {
         Self {
             string: value.string.into(),
···
     }
 }
 
-impl<'a> TryFrom<String> for Ident<Cow<'a, str>> {
+impl TryFrom<String> for Ident<Cow<'_, str>> {
     type Error = IdentError;
 
     fn try_from(value: String) -> Result<Self, Self::Error> {

crates/valence_inventory/src/lib.rs

···
 
             inventory.changed = 0;
             inv_state.slots_changed = 0;
-
-            // Skip updating the cursor item because we just updated the whole inventory.
-            continue;
         } else if inventory.changed != 0 {
             // Send the modified slots.
 

crates/valence_inventory/src/validate.rs

···
                 );
             } else {
                 // If the user clicked on an empty slot for example
-                if packet.slot_changes.len() == 0 {
+                if packet.slot_changes.is_empty() {
                     let count_deltas = calculate_net_item_delta(packet, &window, cursor_item);
                     ensure!(
                         count_deltas == 0,
···
         }
         ClickMode::ShiftClick => {
             // If the user clicked on an empty slot for example
-            if packet.slot_changes.len() == 0 {
+            if packet.slot_changes.is_empty() {
                 let count_deltas = calculate_net_item_delta(packet, &window, cursor_item);
                 ensure!(
                     count_deltas == 0,
···
         }
 
         ClickMode::Hotbar => {
-            if packet.slot_changes.len() == 0 {
+            if packet.slot_changes.is_empty() {
                 let count_deltas = calculate_net_item_delta(packet, &window, cursor_item);
                 ensure!(
                     count_deltas == 0,
···
         }
         ClickMode::CreativeMiddleClick => {}
         ClickMode::DropKey => {
-            if packet.slot_changes.len() == 0 {
+            if packet.slot_changes.is_empty() {
                 let count_deltas = calculate_net_item_delta(packet, &window, cursor_item);
                 ensure!(
                     count_deltas == 0,

crates/valence_nbt/src/serde/de.rs

···
     }
 }
 
-impl<'de> IntoDeserializer<'de, Error> for Compound {
+impl IntoDeserializer<'_, Error> for Compound {
     type Deserializer = Self;
 
     fn into_deserializer(self) -> Self::Deserializer {
···
     }
 }
 
-impl<'de> IntoDeserializer<'de, Error> for Value {
+impl IntoDeserializer<'_, Error> for Value {
     type Deserializer = Self;
 
     fn into_deserializer(self) -> Self::Deserializer {
···
     }
 }
 
-impl<'de> IntoDeserializer<'de, Error> for List {
+impl IntoDeserializer<'_, Error> for List {
     type Deserializer = Self;
 
     fn into_deserializer(self) -> Self::Deserializer {

crates/valence_protocol/src/bit_set.rs

···
             "bit index of {idx} out of range for bitset with {BIT_COUNT} bits"
         );
 
-        self.0[idx / 8] >> (idx % 8) & 1 == 1
+        (self.0[idx / 8] >> (idx % 8)) & 1 == 1
     }
 
     pub fn set_bit(&mut self, idx: usize, val: bool) {
···
 }
 
 const fn check_counts(bits: usize, bytes: usize) {
-    assert!((bits + 7) / 8 == bytes)
+    assert!(bits.div_ceil(8) == bytes)
 }
 
 impl<const BIT_COUNT: usize, const BYTE_COUNT: usize> fmt::Debug

crates/valence_protocol/src/impls/pointer.rs

···
     }
 }
 
-impl<'a, B> Encode for Cow<'a, B>
+impl<B> Encode for Cow<'_, B>
 where
     B: ToOwned + Encode + ?Sized,
 {
···
     }
 }
 
-impl<'a, 'b, B> Decode<'a> for Cow<'b, B>
+impl<'a, B> Decode<'a> for Cow<'_, B>
 where
     B: ToOwned + ?Sized,
     B::Owned: Decode<'a>,

crates/valence_protocol/src/packets/play/chat_message_s2c.rs

···
     PartiallyFiltered,
 }
 
-impl<'a> Encode for ChatMessageS2c<'a> {
+impl Encode for ChatMessageS2c<'_> {
     fn encode(&self, mut w: impl Write) -> anyhow::Result<()> {
         self.sender.encode(&mut w)?;
         self.index.encode(&mut w)?;
···
     pub signature: Option<&'a [u8; 256]>,
 }
 
-impl<'a> Encode for MessageSignature<'a> {
+impl Encode for MessageSignature<'_> {
     fn encode(&self, mut w: impl Write) -> anyhow::Result<()> {
         VarInt(self.message_id + 1).encode(&mut w)?;
 

crates/valence_protocol/src/packets/play/player_list_s2c.rs

···
     pub entries: Cow<'a, [PlayerListEntry<'a>]>,
 }
 
-impl<'a> Encode for PlayerListS2c<'a> {
+impl Encode for PlayerListS2c<'_> {
     fn encode(&self, mut w: impl Write) -> anyhow::Result<()> {
         self.actions.0.encode(&mut w)?;
 

crates/valence_server/src/layer/chunk/chunk.rs

···
     }
 }
 
-impl<'a> IntoBlock for BlockRef<'a> {
+impl IntoBlock for BlockRef<'_> {
     fn into_block(self) -> Block {
         Block {
             state: self.state,

crates/valence_server/src/layer/chunk/paletted_container.rs

···
 
 impl<T: Copy + Eq + Default, const LEN: usize, const HALF_LEN: usize> Indirect<T, LEN, HALF_LEN> {
     pub(super) fn get(&self, idx: usize) -> T {
-        let palette_idx = self.indices[idx / 2] >> (idx % 2 * 4) & 0b1111;
+        let palette_idx = (self.indices[idx / 2] >> (idx % 2 * 4)) & 0b1111;
         self.palette[palette_idx as usize]
     }
 

crates/valence_server/src/layer/entity.rs

···
     pos: ChunkPos,
 }
 
-impl<'a> WritePacket for ViewWriter<'a> {
+impl WritePacket for ViewWriter<'_> {
     fn write_packet_fallible<P>(&mut self, packet: &P) -> anyhow::Result<()>
     where
         P: Packet + Encode,

crates/valence_text/src/color.rs

···
 
         if let &[b'#', r0, r1, g0, g1, b0, b1] = value.as_bytes() {
             Ok(RgbColor {
-                r: to_num(r0)? << 4 | to_num(r1)?,
-                g: to_num(g0)? << 4 | to_num(g1)?,
-                b: to_num(b0)? << 4 | to_num(b1)?,
+                r: (to_num(r0)? << 4) | to_num(r1)?,
+                g: (to_num(g0)? << 4) | to_num(g1)?,
+                b: (to_num(b0)? << 4) | to_num(b1)?,
             })
         } else {
             Err(ColorError)
···
 
 struct ColorVisitor;
 
-impl<'de> Visitor<'de> for ColorVisitor {
+impl Visitor<'_> for ColorVisitor {
     type Value = Color;
 
     fn expecting(&self, f: &mut fmt::Formatter) -> fmt::Result {

crates/valence_text/src/into_text.rs

···
         value.into_owned()
     }
 }
-impl<'a, 'b> IntoText<'a> for &'a Cow<'b, Text> {
+impl<'a> IntoText<'a> for &'a Cow<'_, Text> {
     fn into_cow_text(self) -> Cow<'a, Text> {
         self.clone()
     }
···
         value.into_text()
     }
 }
-impl<'a, 'b> IntoText<'b> for &'a String {
+impl<'b> IntoText<'b> for &String {
     fn into_cow_text(self) -> Cow<'b, Text> {
         Cow::Owned(Text::text(self.clone()))
     }
···
         value.into_text()
     }
 }
-impl<'a> IntoText<'static> for &'a Cow<'static, str> {
+impl IntoText<'static> for &Cow<'static, str> {
     fn into_cow_text(self) -> Cow<'static, Text> {
         Cow::Owned(Text::text(self.clone()))
     }
···
     }
 }
 
-impl<'a, 'b, 'c, T: IntoText<'a> + Clone, const N: usize> IntoText<'c> for &'b [T; N] {
+impl<'a, 'c, T: IntoText<'a> + Clone, const N: usize> IntoText<'c> for &[T; N] {
     fn into_cow_text(self) -> Cow<'c, Text> {
         let mut txt = Text::text("");
 

crates/valence_text/src/lib.rs

···
                 this.0.underlined,
                 this.0.italic,
             ]
-            .iter()
-            .any(|m| *m == Some(false))
+            .contains(&Some(false))
                 || this.0.color == Some(Color::Reset)
             {
                 // Reset and print sum of old and new modifiers
···
     }
 }
 
-impl<'a> From<Text> for Cow<'a, Text> {
+impl From<Text> for Cow<'_, Text> {
     fn from(value: Text) -> Self {
         Cow::Owned(value)
     }

tools/packet_inspector/src/tri_checkbox.rs

···
     }
 }
 
-impl<'a> Widget for TriCheckbox<'a> {
+impl Widget for TriCheckbox<'_> {
     fn ui(self, ui: &mut Ui) -> Response {
         let TriCheckbox { checked, text } = self;
 

tools/stresser/src/stresser.rs

···
     pub read_buffer_size: usize,
 }
 
-pub async fn make_session<'a>(params: &SessionParams<'a>) -> anyhow::Result<()> {
+pub async fn make_session(params: &SessionParams<'_>) -> anyhow::Result<()> {
     let sock_addr = params.socket_addr;
     let sess_name = params.session_name;
     let rb_size = params.read_buffer_size;