A bunch of clippy fixes

ReCore-sys · ReCore-sys · commit 89cca3830a89 · 2024-10-22T18:00:53.000+10:30
diff --git a/src/lib/adapters/nbt/benches/ferrumc-nbt.rs b/src/lib/adapters/nbt/benches/ferrumc-nbt.rs
@@ -17,7 +17,7 @@ mod structs {
         pub(crate) z_pos: i32,
         #[nbt(rename = "Heightmaps")]
         pub(crate) heightmaps: Heightmaps<'a>,
-        sections: Vec<Section<'a>>,
+        _sections: Vec<Section<'a>>,
     }
 
     #[derive(NBTDeserialize)]
@@ -29,20 +29,20 @@ mod structs {
     #[derive(NBTDeserialize)]
     pub(super) struct Section<'a> {
         #[nbt(rename = "Y")]
-        y: i8,
-        block_states: Option<BlockState<'a>>,
+        _y: i8,
+        _block_states: Option<BlockState<'a>>,
     }
 
     #[derive(NBTDeserialize)]
     pub(super) struct BlockState<'a> {
-        pub(crate) data: Option<&'a [i64]>,
-        pub(crate) palette: Vec<Palette<'a>>,
+        pub(crate) _data: Option<&'a [i64]>,
+        pub(crate) _palette: Vec<Palette<'a>>,
     }
 
     #[derive(NBTDeserialize)]
     pub(super) struct Palette<'a> {
         #[nbt(rename = "Name")]
-        pub(crate) name: &'a str,
+        pub(crate) _name: &'a str,
     }
 }
 fn bench_ferrumc_nbt(data: &[u8]) {
@@ -76,7 +76,7 @@ fn bench_simdnbt(data: &[u8]) {
         .unwrap()
         .into_iter()
         .filter_map(|section| {
-            let y = section.get("Y").unwrap().byte().unwrap();
+            let _ = section.get("Y").unwrap().byte().unwrap();
             let block_states = section.get("block_states")?;
             let block_states = block_states.compound().unwrap();
             let data = block_states.get("data")?;
@@ -92,12 +92,12 @@ fn bench_simdnbt(data: &[u8]) {
                     let str = name.to_str();
                     let name = str.as_ref();
                     let name = Box::leak(name.to_string().into_boxed_str());
-                    Palette { name }
+                    Palette { _name: name }
                 })
                 .collect();
             Some(BlockState {
-                data: Some(data),
-                palette,
+                _data: Some(data),
+                _palette: palette,
             })
         })
         .collect::<Vec<_>>();
diff --git a/src/lib/adapters/nbt/src/de/borrow.rs b/src/lib/adapters/nbt/src/de/borrow.rs
@@ -292,7 +292,7 @@ impl<'a> NbtTape<'a> {
         }
     }
 }
-impl<'a> NbtTape<'a> {
+impl NbtTape<'_> {
     /// Skips over a single tag based on its type.
     fn skip_tag(&mut self, tag: u8) -> usize {
         let start_pos = self.pos;
@@ -391,71 +391,71 @@ pub trait NbtDeserializable<'a>: Sized {
 
 mod primitives {
     use super::NbtDeserializable;
-    impl<'a> NbtDeserializable<'a> for i8 {
+    impl NbtDeserializable<'_> for i8 {
         fn parse_from_bytes(data: &[u8]) -> Self {
             data[0] as i8
         }
     }
-    impl<'a> NbtDeserializable<'a> for u8 {
+    impl NbtDeserializable<'_> for u8 {
         fn parse_from_bytes(data: &[u8]) -> Self {
             u8::from_be_bytes([data[0]])
         }
     }
-    impl<'a> NbtDeserializable<'a> for i16 {
+    impl NbtDeserializable<'_> for i16 {
         fn parse_from_bytes(data: &[u8]) -> Self {
             i16::from_be_bytes([data[0], data[1]])
         }
     }
 
-    impl<'a> NbtDeserializable<'a> for u16 {
+    impl NbtDeserializable<'_> for u16 {
         fn parse_from_bytes(data: &[u8]) -> Self {
             u16::from_be_bytes([data[0], data[1]])
         }
     }
 
-    impl<'a> NbtDeserializable<'a> for i32 {
+    impl NbtDeserializable<'_> for i32 {
         fn parse_from_bytes(data: &[u8]) -> Self {
             i32::from_be_bytes([data[0], data[1], data[2], data[3]])
         }
     }
 
-    impl<'a> NbtDeserializable<'a> for u32 {
+    impl NbtDeserializable<'_> for u32 {
         fn parse_from_bytes(data: &[u8]) -> Self {
             u32::from_be_bytes([data[0], data[1], data[2], data[3]])
         }
     }
 
-    impl<'a> NbtDeserializable<'a> for i64 {
+    impl NbtDeserializable<'_> for i64 {
         fn parse_from_bytes(data: &[u8]) -> Self {
             i64::from_be_bytes([
                 data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7],
             ])
         }
     }
 
-    impl<'a> NbtDeserializable<'a> for u64 {
+    impl NbtDeserializable<'_> for u64 {
         fn parse_from_bytes(data: &[u8]) -> Self {
             u64::from_be_bytes([
                 data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7],
             ])
         }
     }
 
-    impl<'a> NbtDeserializable<'a> for f32 {
+    impl NbtDeserializable<'_> for f32 {
         fn parse_from_bytes(data: &[u8]) -> Self {
             f32::from_be_bytes([data[0], data[1], data[2], data[3]])
         }
     }
 
-    impl<'a> NbtDeserializable<'a> for f64 {
+    impl NbtDeserializable<'_> for f64 {
         fn parse_from_bytes(data: &[u8]) -> Self {
             f64::from_be_bytes([
                 data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7],
             ])
         }
     }
 
-    impl<'a> NbtDeserializable<'a> for bool {
+    impl NbtDeserializable<'_> for bool {
         fn parse_from_bytes(data: &[u8]) -> Self {
             data[0] != 0
         }
@@ -621,7 +621,7 @@ impl<'a> NetEncode for NbtTape<'a> {
 }
 
 
-impl<'a> NbtTapeElement<'a> {
+impl NbtTapeElement<'_> {
     pub fn serialize_as_network(&self, tape: &mut NbtTape, writer: &mut Vec<u8>, opts: &NBTSerializeOptions) -> NetEncodeResult<()> {
         /*if let NBTSerializeOptions::WithHeader(name) = opts {
             writer.write_all(&[self.nbt_id()])?;
diff --git a/src/lib/adapters/nbt/src/ser/impl.rs b/src/lib/adapters/nbt/src/ser/impl.rs
@@ -90,7 +90,7 @@ impl<T: NBTSerializable + std::fmt::Debug> NBTSerializable for Vec<T> {
     }
 }
 
-impl<'a, T: NBTSerializable> NBTSerializable for &'a [T] {
+impl<T: NBTSerializable> NBTSerializable for &'_ [T] {
     fn serialize(&self, buf: &mut Vec<u8>, options: &NBTSerializeOptions<'_>) {
         write_header::<Self>(buf, options);
 
@@ -149,11 +149,8 @@ impl<'a, T: NBTSerializable> NBTSerializable for &'a [T] {
 
 impl<T: NBTSerializable> NBTSerializable for Option<T> {
     fn serialize(&self, buf: &mut Vec<u8>, options: &NBTSerializeOptions<'_>) {
-        match self {
-            Some(value) => {
-                value.serialize(buf, options);
-            }
-            None => {}
+        if let Some(value) = self {
+            value.serialize(buf, options);
         }
     }
 
diff --git a/src/lib/ecs/src/components/mod.rs b/src/lib/ecs/src/components/mod.rs
@@ -38,7 +38,7 @@ impl ComponentStorage {
         let mut components = self
             .components
             .entry(type_id)
-            .or_insert_with(SparseSet::new);
+            .or_default();
         components.insert(entity, RwLock::new(Box::new(component)));
     }
 
@@ -127,36 +127,36 @@ mod debug {
     use std::fmt::Debug;
     use crate::components::{Component, ComponentRef, ComponentRefMut};
 
-    impl<'a, T: Component + Debug> Debug for ComponentRef<'a, T> {
+    impl<T: Component + Debug> Debug for ComponentRef<'_, T> {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             Debug::fmt(&**self, f)
         }
     }
     
-    impl<'a, T: Component + Debug> Debug for ComponentRefMut<'a, T> {
+    impl<T: Component + Debug> Debug for ComponentRefMut<'_, T> {
         fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
             Debug::fmt(&**self, f)
         }
     }
 }
 
-impl<'a, T: Component> Deref for ComponentRef<'a, T> {
+impl<T: Component> Deref for ComponentRef<'_, T> {
     type Target = T;
 
     fn deref(&self) -> &Self::Target {
         unsafe { &*(&**self.read_guard as *const dyn Component as *const T) }
     }
 }
 
-impl<'a, T: Component> Deref for ComponentRefMut<'a, T> {
+impl<T: Component> Deref for ComponentRefMut<'_, T> {
     type Target = T;
 
     fn deref(&self) -> &Self::Target {
         unsafe { &*(&**self.write_guard as *const dyn Component as *const T) }
     }
 }
 
-impl<'a, T: Component> DerefMut for ComponentRefMut<'a, T> {
+impl<T: Component> DerefMut for ComponentRefMut<'_, T> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         unsafe { &mut *(&mut **self.write_guard as *mut dyn Component as *mut T) }
     }
diff --git a/src/lib/ecs/src/components/sparse_set.rs b/src/lib/ecs/src/components/sparse_set.rs
@@ -9,6 +9,12 @@ pub struct SparseSet<T> {
     indices: HashMap<Entity, usize>,
 }
 
+impl<T> Default for SparseSet<T> {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl<T> SparseSet<T> {
     pub fn new() -> Self {
         SparseSet {
diff --git a/src/lib/ecs/src/query.rs b/src/lib/ecs/src/query.rs
@@ -58,7 +58,7 @@ pub struct Query<'a, Q: QueryItem> {
     _marker: std::marker::PhantomData<Q>,
 }
 
-impl<'a, Q: QueryItem> Clone for Query<'a, Q> {
+impl<Q: QueryItem> Clone for Query<'_, Q> {
     fn clone(&self) -> Self {
         //! Clones the query, and re-calculates the entities
         Self {
diff --git a/src/lib/ecs/src/tests/mod.rs b/src/lib/ecs/src/tests/mod.rs
@@ -7,6 +7,7 @@ use rayon::prelude::*;
 
 
 #[derive(Debug)]
+#[expect(dead_code)]
 struct Position {
     x: u32,
     y: u32,
@@ -15,6 +16,7 @@ struct Position {
 unsafe impl Send for Position {}
 
 #[derive(Debug)]
+#[expect(dead_code)]
 struct Player {
     username: String,
 }
@@ -36,7 +38,7 @@ fn test_basic() {
     let query = Query::<(&Player, &mut Position)>::new(&component_storage);
     
     let start = Instant::now();
-    ParallelIterator::for_each(query.into_par_iter(), |(player, position)| {
+    ParallelIterator::for_each(query.into_par_iter(), |(_player, position)| {
         let sleep_duration = Duration::from_millis(100 * (position.x as u64));
         thread::sleep(sleep_duration);
     });
diff --git a/src/lib/events/src/infrastructure.rs b/src/lib/events/src/infrastructure.rs
@@ -159,7 +159,7 @@ pub trait Event: Sized + Send + Sync + 'static {
         Ok(())
     }
 */
-    /// Register a a new event listener for this event
+    /// Register a new event listener for this event
     fn register(listener: AsyncEventListener<Self>, priority: u8) {
         // Create the event listener structure
         let listener = EventListener::<Self> { listener, priority };
diff --git a/src/lib/events/src/tests/mod.rs b/src/lib/events/src/tests/mod.rs
@@ -17,6 +17,7 @@ pub enum SomeEventError {}
 
 impl Event for SomeEvent {
     type Data = Self;
+    type State = ();
 
     type Error = SomeEventError;
 
@@ -29,7 +30,7 @@ impl Event for SomeEvent {
 async fn test_something() {
     let event_data = SomeEvent { data: 0 };
 
-    SomeEvent::trigger(event_data).await.unwrap();
+    SomeEvent::trigger(event_data, ()).await.unwrap();
 }
 
 // #[ctor::ctor]
@@ -56,7 +57,7 @@ async fn test_something() {
 
 #[ctor::ctor]
 fn __register_some_event_listener() {
-    SomeEvent::register(|ev: SomeEvent| Box::pin(some_event_listener(ev)), 0);
+    SomeEvent::register(|ev: SomeEvent, _: ()| Box::pin(some_event_listener(ev)), 0);
 }
 
 async fn some_event_listener(mut event: SomeEvent) -> Result<SomeEvent, SomeEventError> {
@@ -67,7 +68,7 @@ async fn some_event_listener(mut event: SomeEvent) -> Result<SomeEvent, SomeEven
 
 #[ctor::ctor]
 fn __register_some_event_listener2() {
-    SomeEvent::register(|ev: SomeEvent| Box::pin(some_event_listener2(ev)), 255);
+    SomeEvent::register(|ev: SomeEvent, _: ()| Box::pin(some_event_listener2(ev)), 255);
 }
 
 async fn some_event_listener2(event: SomeEvent) -> Result<SomeEvent, SomeEventError> {
diff --git a/src/lib/net/src/packets/outgoing/client_bound_known_packs.rs b/src/lib/net/src/packets/outgoing/client_bound_known_packs.rs
@@ -16,13 +16,13 @@ pub struct Pack<'a> {
     pub version: &'a str,
 }
 
-impl<'a> Default for ClientBoundKnownPacksPacket<'a> {
+impl Default for ClientBoundKnownPacksPacket<'_> {
     fn default() -> Self {
         Self::new()
     }
 }
 
-impl<'a> ClientBoundKnownPacksPacket<'a> {
+impl ClientBoundKnownPacksPacket<'_> {
     pub fn new() -> Self {
         Self {
             packs: LengthPrefixedVec::new(vec![Pack::new("minecraft", "core", "1.21")]),
diff --git a/src/lib/net/src/packets/outgoing/login_play.rs b/src/lib/net/src/packets/outgoing/login_play.rs
@@ -30,7 +30,7 @@ pub struct LoginPlayPacket<'a> {
     pub enforces_secure_chat: bool,
 }
 
-impl<'a> LoginPlayPacket<'a> {
+impl LoginPlayPacket<'_> {
     pub fn new(conn_id: usize) -> Self {
         Self {
             entity_id: conn_id as i32,
diff --git a/src/lib/net/src/packets/outgoing/registry_data.rs b/src/lib/net/src/packets/outgoing/registry_data.rs
@@ -27,7 +27,7 @@ pub struct RegistryEntry<'a> {
     pub data: Vec<u8>,
 }
 
-impl<'a> RegistryDataPacket<'a> {
+impl RegistryDataPacket<'_> {
     // TODO: bake this. and make it return just the bytes instead.
     pub fn get_registry_packets() -> Vec<Self> {
         let registry_nbt_buf = include_bytes!("../../../../../../.etc/registry.nbt");
@@ -80,7 +80,7 @@ pub const fn get_registry_packets() -> &'static [u8] {
 mod tests {
     use std::io::Write;
 
-    use ferrumc_nbt::NbtTape;
+    use ferrumc_nbt::{NBTSerializeOptions, NbtTape};
     use ferrumc_net_codec::encode::{NetEncode, NetEncodeOpts};
     use tracing::debug;
 
@@ -1235,7 +1235,7 @@ mod tests {
                         let has_data = true;
                         let mut data = vec![];
                         element
-                            .serialize_as_network(&mut rewind_machine, &mut data)
+                            .serialize_as_network(&mut rewind_machine, &mut data, &NBTSerializeOptions::Network)
                             .unwrap_or_else(|_| {
                                 panic!("Failed to serialize entry for {}", registry_id)
                             });
diff --git a/src/lib/storage/src/backends/surrealkv.rs b/src/lib/storage/src/backends/surrealkv.rs
@@ -182,8 +182,8 @@ impl DatabaseBackend for SurrealKVBackend {
     async fn create_table(&mut self, _: String) -> Result<(), StorageError> {
         Ok(())
     }
+    #[expect(clippy::await_holding_lock)]
     async fn close(&mut self) -> Result<(), StorageError> {
-        #[allow(clippy::await_holding_lock)]
         let write_guard = self.db.write();
         let res = write_guard.close().await;
         drop(write_guard);
diff --git a/src/lib/utils/config/src/server_config.rs b/src/lib/utils/config/src/server_config.rs
@@ -164,7 +164,7 @@ impl ServerConfig {
                 std::io::stdin().read_line(&mut input)?;
 
                 // If the user enters "y", create a new configuration file.
-                if input.trim().to_ascii_lowercase() == "y" {
+                if input.trim().eq_ignore_ascii_case("y") {
                     // Backup the old configuration file.
                     std::fs::rename(&path, "config.toml.bak")?;
 
diff --git a/src/tests/src/nbt/ser.rs b/src/tests/src/nbt/ser.rs
diff --git a/src/tests/src/net/codec/enc/mod.rs b/src/tests/src/net/codec/enc/mod.rs

Original file line number	Diff line number	Diff line change
`@@ -292,7 +292,7 @@ impl<'a> NbtTape<'a> {`
`292`	`292`	`}`
`293`	`293`	`}`
`294`	`294`	`}`
`295`		`-impl<'a> NbtTape<'a> {`
	`295`	`+impl NbtTape<'_> {`
`296`	`296`	`/// Skips over a single tag based on its type.`
`297`	`297`	`fn skip_tag(&mut self, tag: u8) -> usize {`
`298`	`298`	`let start_pos = self.pos;`
`@@ -391,71 +391,71 @@ pub trait NbtDeserializable<'a>: Sized {`
`391`	`391`
`392`	`392`	`mod primitives {`
`393`	`393`	`use super::NbtDeserializable;`
`394`		`- impl<'a> NbtDeserializable<'a> for i8 {`
	`394`	`+ impl NbtDeserializable<'_> for i8 {`
`395`	`395`	`fn parse_from_bytes(data: &[u8]) -> Self {`
`396`	`396`	`data[0] as i8`
`397`	`397`	`}`
`398`	`398`	`}`
`399`		`- impl<'a> NbtDeserializable<'a> for u8 {`
	`399`	`+ impl NbtDeserializable<'_> for u8 {`
`400`	`400`	`fn parse_from_bytes(data: &[u8]) -> Self {`
`401`	`401`	`u8::from_be_bytes([data[0]])`
`402`	`402`	`}`
`403`	`403`	`}`
`404`		`- impl<'a> NbtDeserializable<'a> for i16 {`
	`404`	`+ impl NbtDeserializable<'_> for i16 {`
`405`	`405`	`fn parse_from_bytes(data: &[u8]) -> Self {`
`406`	`406`	`i16::from_be_bytes([data[0], data[1]])`
`407`	`407`	`}`
`408`	`408`	`}`
`409`	`409`
`410`		`- impl<'a> NbtDeserializable<'a> for u16 {`
	`410`	`+ impl NbtDeserializable<'_> for u16 {`
`411`	`411`	`fn parse_from_bytes(data: &[u8]) -> Self {`
`412`	`412`	`u16::from_be_bytes([data[0], data[1]])`
`413`	`413`	`}`
`414`	`414`	`}`
`415`	`415`
`416`		`- impl<'a> NbtDeserializable<'a> for i32 {`
	`416`	`+ impl NbtDeserializable<'_> for i32 {`
`417`	`417`	`fn parse_from_bytes(data: &[u8]) -> Self {`
`418`	`418`	`i32::from_be_bytes([data[0], data[1], data[2], data[3]])`
`419`	`419`	`}`
`420`	`420`	`}`
`421`	`421`
`422`		`- impl<'a> NbtDeserializable<'a> for u32 {`
	`422`	`+ impl NbtDeserializable<'_> for u32 {`
`423`	`423`	`fn parse_from_bytes(data: &[u8]) -> Self {`
`424`	`424`	`u32::from_be_bytes([data[0], data[1], data[2], data[3]])`
`425`	`425`	`}`
`426`	`426`	`}`
`427`	`427`
`428`		`- impl<'a> NbtDeserializable<'a> for i64 {`
	`428`	`+ impl NbtDeserializable<'_> for i64 {`
`429`	`429`	`fn parse_from_bytes(data: &[u8]) -> Self {`
`430`	`430`	`i64::from_be_bytes([`
`431`	`431`	`data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7],`
`432`	`432`	`])`
`433`	`433`	`}`
`434`	`434`	`}`
`435`	`435`
`436`		`- impl<'a> NbtDeserializable<'a> for u64 {`
	`436`	`+ impl NbtDeserializable<'_> for u64 {`
`437`	`437`	`fn parse_from_bytes(data: &[u8]) -> Self {`
`438`	`438`	`u64::from_be_bytes([`
`439`	`439`	`data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7],`
`440`	`440`	`])`
`441`	`441`	`}`
`442`	`442`	`}`
`443`	`443`
`444`		`- impl<'a> NbtDeserializable<'a> for f32 {`
	`444`	`+ impl NbtDeserializable<'_> for f32 {`
`445`	`445`	`fn parse_from_bytes(data: &[u8]) -> Self {`
`446`	`446`	`f32::from_be_bytes([data[0], data[1], data[2], data[3]])`
`447`	`447`	`}`
`448`	`448`	`}`
`449`	`449`
`450`		`- impl<'a> NbtDeserializable<'a> for f64 {`
	`450`	`+ impl NbtDeserializable<'_> for f64 {`
`451`	`451`	`fn parse_from_bytes(data: &[u8]) -> Self {`
`452`	`452`	`f64::from_be_bytes([`
`453`	`453`	`data[0], data[1], data[2], data[3], data[4], data[5], data[6], data[7],`
`454`	`454`	`])`
`455`	`455`	`}`
`456`	`456`	`}`
`457`	`457`
`458`		`- impl<'a> NbtDeserializable<'a> for bool {`
	`458`	`+ impl NbtDeserializable<'_> for bool {`
`459`	`459`	`fn parse_from_bytes(data: &[u8]) -> Self {`
`460`	`460`	`data[0] != 0`
`461`	`461`	`}`
`@@ -621,7 +621,7 @@ impl<'a> NetEncode for NbtTape<'a> {`
`621`	`621`	`}`
`622`	`622`
`623`	`623`
`624`		`-impl<'a> NbtTapeElement<'a> {`
	`624`	`+impl NbtTapeElement<'_> {`
`625`	`625`	`pub fn serialize_as_network(&self, tape: &mut NbtTape, writer: &mut Vec<u8>, opts: &NBTSerializeOptions) -> NetEncodeResult<()> {`
`626`	`626`	`/*if let NBTSerializeOptions::WithHeader(name) = opts {`
`627`	`627`	`writer.write_all(&[self.nbt_id()])?;`
Original file line number	Diff line number	Diff line change
`@@ -90,7 +90,7 @@ impl<T: NBTSerializable + std::fmt::Debug> NBTSerializable for Vec<T> {`
`90`	`90`	`}`
`91`	`91`	`}`
`92`	`92`
`93`		`-impl<'a, T: NBTSerializable> NBTSerializable for &'a [T] {`
	`93`	`+impl<T: NBTSerializable> NBTSerializable for &'_ [T] {`
`94`	`94`	`fn serialize(&self, buf: &mut Vec<u8>, options: &NBTSerializeOptions<'_>) {`
`95`	`95`	`write_header::<Self>(buf, options);`
`96`	`96`
`@@ -149,11 +149,8 @@ impl<'a, T: NBTSerializable> NBTSerializable for &'a [T] {`
`149`	`149`
`150`	`150`	`impl<T: NBTSerializable> NBTSerializable for Option<T> {`
`151`	`151`	`fn serialize(&self, buf: &mut Vec<u8>, options: &NBTSerializeOptions<'_>) {`
`152`		`- match self {`
`153`		`- Some(value) => {`
`154`		`- value.serialize(buf, options);`
`155`		`- }`
`156`		`- None => {}`
	`152`	`+ if let Some(value) = self {`
	`153`	`+ value.serialize(buf, options);`
`157`	`154`	`}`
`158`	`155`	`}`
`159`	`156`
Original file line number	Diff line number	Diff line change
`@@ -38,7 +38,7 @@ impl ComponentStorage {`
`38`	`38`	`let mut components = self`
`39`	`39`	`.components`
`40`	`40`	`.entry(type_id)`
`41`		`- .or_insert_with(SparseSet::new);`
	`41`	`+ .or_default();`
`42`	`42`	`components.insert(entity, RwLock::new(Box::new(component)));`
`43`	`43`	`}`
`44`	`44`
`@@ -127,36 +127,36 @@ mod debug {`
`127`	`127`	`use std::fmt::Debug;`
`128`	`128`	`use crate::components::{Component, ComponentRef, ComponentRefMut};`
`129`	`129`
`130`		`- impl<'a, T: Component + Debug> Debug for ComponentRef<'a, T> {`
	`130`	`+ impl<T: Component + Debug> Debug for ComponentRef<'_, T> {`
`131`	`131`	`fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {`
`132`	`132`	`Debug::fmt(&**self, f)`
`133`	`133`	`}`
`134`	`134`	`}`
`135`	`135`
`136`		`- impl<'a, T: Component + Debug> Debug for ComponentRefMut<'a, T> {`
	`136`	`+ impl<T: Component + Debug> Debug for ComponentRefMut<'_, T> {`
`137`	`137`	`fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {`
`138`	`138`	`Debug::fmt(&**self, f)`
`139`	`139`	`}`
`140`	`140`	`}`
`141`	`141`	`}`
`142`	`142`
`143`		`-impl<'a, T: Component> Deref for ComponentRef<'a, T> {`
	`143`	`+impl<T: Component> Deref for ComponentRef<'_, T> {`
`144`	`144`	`type Target = T;`
`145`	`145`
`146`	`146`	`fn deref(&self) -> &Self::Target {`
`147`	`147`	`unsafe { &(&self.read_guard as const dyn Component as *const T) }`
`148`	`148`	`}`
`149`	`149`	`}`
`150`	`150`
`151`		`-impl<'a, T: Component> Deref for ComponentRefMut<'a, T> {`
	`151`	`+impl<T: Component> Deref for ComponentRefMut<'_, T> {`
`152`	`152`	`type Target = T;`
`153`	`153`
`154`	`154`	`fn deref(&self) -> &Self::Target {`
`155`	`155`	`unsafe { &(&self.write_guard as const dyn Component as *const T) }`
`156`	`156`	`}`
`157`	`157`	`}`
`158`	`158`
`159`		`-impl<'a, T: Component> DerefMut for ComponentRefMut<'a, T> {`
	`159`	`+impl<T: Component> DerefMut for ComponentRefMut<'_, T> {`
`160`	`160`	`fn deref_mut(&mut self) -> &mut Self::Target {`
`161`	`161`	`unsafe { &mut (&mut self.write_guard as mut dyn Component as *mut T) }`
`162`	`162`	`}`
Original file line number	Diff line number	Diff line change
`@@ -58,7 +58,7 @@ pub struct Query<'a, Q: QueryItem> {`
`58`	`58`	`_marker: std::marker::PhantomData<Q>,`
`59`	`59`	`}`
`60`	`60`
`61`		`-impl<'a, Q: QueryItem> Clone for Query<'a, Q> {`
	`61`	`+impl<Q: QueryItem> Clone for Query<'_, Q> {`
`62`	`62`	`fn clone(&self) -> Self {`
`63`	`63`	`//! Clones the query, and re-calculates the entities`
`64`	`64`	`Self {`
Original file line number	Diff line number	Diff line change
`@@ -159,7 +159,7 @@ pub trait Event: Sized + Send + Sync + 'static {`
`159`	`159`	`Ok(())`
`160`	`160`	`}`
`161`	`161`	`*/`
`162`		`- /// Register a a new event listener for this event`
	`162`	`+ /// Register a new event listener for this event`
`163`	`163`	`fn register(listener: AsyncEventListener<Self>, priority: u8) {`
`164`	`164`	`// Create the event listener structure`
`165`	`165`	`let listener = EventListener::<Self> { listener, priority };`
Original file line number	Diff line number	Diff line change
`@@ -16,13 +16,13 @@ pub struct Pack<'a> {`
`16`	`16`	`pub version: &'a str,`
`17`	`17`	`}`
`18`	`18`
`19`		`-impl<'a> Default for ClientBoundKnownPacksPacket<'a> {`
	`19`	`+impl Default for ClientBoundKnownPacksPacket<'_> {`
`20`	`20`	`fn default() -> Self {`
`21`	`21`	`Self::new()`
`22`	`22`	`}`
`23`	`23`	`}`
`24`	`24`
`25`		`-impl<'a> ClientBoundKnownPacksPacket<'a> {`
	`25`	`+impl ClientBoundKnownPacksPacket<'_> {`
`26`	`26`	`pub fn new() -> Self {`
`27`	`27`	`Self {`
`28`	`28`	`packs: LengthPrefixedVec::new(vec![Pack::new("minecraft", "core", "1.21")]),`
Original file line number	Diff line number	Diff line change
`@@ -30,7 +30,7 @@ pub struct LoginPlayPacket<'a> {`
`30`	`30`	`pub enforces_secure_chat: bool,`
`31`	`31`	`}`
`32`	`32`
`33`		`-impl<'a> LoginPlayPacket<'a> {`
	`33`	`+impl LoginPlayPacket<'_> {`
`34`	`34`	`pub fn new(conn_id: usize) -> Self {`
`35`	`35`	`Self {`
`36`	`36`	`entity_id: conn_id as i32,`