upgrade rust version and fix clippy warnings

azalea-brigadier/src/command_dispatcher.rs

@@ -467,7 +467,7 @@ impl<S> CommandDispatcher<S> {
                     Ordering::Equal => {
                         let usage = child_usage.into_iter().next().unwrap();
                         let usage = if child_optional {
-                            format!("[{}]", usage)
+                            format!("[{usage}]")
                         } else {
                             usage
                         };

azalea-client/src/local_player.rs

@@ -152,8 +152,10 @@ impl InstanceHolder {
     pub fn reset(&mut self) {
         let registries = self.instance.read().registries.clone();
 
-        let mut new_instance = Instance::default();
-        new_instance.registries = registries;
+        let new_instance = Instance {
+            registries,
+            ..Default::default()
+        };
         self.instance = Arc::new(RwLock::new(new_instance));
 
         self.partial_instance.write().reset();

azalea-client/src/plugins/auto_reconnect.rs

@@ -72,10 +72,8 @@ fn get_delay(
 ) -> Option<Duration> {
     if let Ok(c) = auto_reconnect_delay_query.get(entity) {
         Some(c.delay)
-    } else if let Some(r) = &auto_reconnect_delay_res {
-        Some(r.delay)
     } else {
-        None
+        auto_reconnect_delay_res.as_ref().map(|r| r.delay)
     }
 }
 

azalea-client/src/plugins/mining.rs

@@ -580,7 +580,7 @@ pub fn continue_mining_block(
             let instance = instance_lock.read();
             let target_block_state = instance.get_block_state(&mining.pos).unwrap_or_default();
 
-            println!("target_block_state: {:?}", target_block_state);
+            println!("target_block_state: {target_block_state:?}");
 
             if target_block_state.is_air() {
                 commands.entity(entity).remove::<Mining>();

azalea-protocol/src/lib.rs

@@ -197,7 +197,7 @@ mod tests {
 
         let buf = compression_encoder(&buf, compression_threshold).unwrap();
 
-        println!("{:?}", buf);
+        println!("{buf:?}");
 
         compression_decoder(&mut Cursor::new(&buf), compression_threshold).unwrap();
     }

azalea-protocol/src/packets/game/c_container_set_content.rs

@@ -29,7 +29,7 @@ mod tests {
         ];
         let mut buf = Cursor::new(contents.as_slice());
         let packet = ClientboundContainerSetContent::azalea_read(&mut buf).unwrap();
-        println!("{:?}", packet);
+        println!("{packet:?}");
 
         assert_eq!(buf.position(), contents.len() as u64);
 

azalea-protocol/src/packets/game/c_server_links.rs

@@ -28,7 +28,7 @@ mod tests {
         ];
         let mut buf = Cursor::new(contents.as_slice());
         let packet = ClientboundServerLinks::azalea_read(&mut buf).unwrap();
-        println!("{:?}", packet);
+        println!("{packet:?}");
 
         assert_eq!(buf.position(), contents.len() as u64);
     }

azalea-protocol/src/packets/game/c_set_entity_data.rs

@@ -23,7 +23,7 @@ mod tests {
         let contents = [161, 226, 1, 10, 18, 1, 20, 38, 124, 175, 198, 255];
         let mut buf = Cursor::new(contents.as_slice());
         let packet = ClientboundSetEntityData::azalea_read(&mut buf).unwrap();
-        println!("{:?}", packet);
+        println!("{packet:?}");
 
         assert_eq!(buf.position(), contents.len() as u64);
 
@@ -44,7 +44,7 @@ mod tests {
         ];
         let mut buf = Cursor::new(contents.as_slice());
         let packet = ClientboundSetEntityData::azalea_read(&mut buf).unwrap();
-        println!("{:?}", packet);
+        println!("{packet:?}");
 
         assert_eq!(buf.position(), contents.len() as u64);
     }

azalea-protocol/src/packets/game/c_set_player_team.rs

@@ -63,7 +63,7 @@ mod tests {
         ];
         let mut buf = Cursor::new(contents.as_slice());
         let packet = ClientboundSetPlayerTeam::azalea_read(&mut buf).unwrap();
-        println!("{:?}", packet);
+        println!("{packet:?}");
 
         assert_eq!(buf.position(), contents.len() as u64);
     }

azalea-protocol/src/packets/game/c_sound.rs

@@ -47,7 +47,7 @@ mod tests {
         ];
         let mut buf = Cursor::new(contents.as_slice());
         let packet = ClientboundSound::azalea_read(&mut buf).unwrap();
-        println!("{:?}", packet);
+        println!("{packet:?}");
 
         assert_eq!(buf.position(), contents.len() as u64);
 

azalea/examples/steal.rs

@@ -58,11 +58,10 @@ async fn steal(bot: Client, state: State) -> anyhow::Result<()> {
             .world()
             .read()
             .find_blocks(bot.position(), &azalea::registry::Block::Chest.into())
-            .filter(
-                // filter for chests that haven't been checked
-                |block_pos| !state.checked_chests.lock().contains(&block_pos),
-            )
-            .next();
+            .find(
+                // find the closest chest that hasn't been checked
+                |block_pos| !state.checked_chests.lock().contains(block_pos),
+            );
         let Some(chest_block) = chest_block else {
             break;
         };

azalea/examples/testbot/commands/debug.rs

@@ -226,7 +226,7 @@ pub fn register(commands: &mut CommandDispatcher<Mutex<CommandSource>>) {
                         let instance_container = ecs.resource::<InstanceContainer>();
 
                         for (instance_name, instance) in &instance_container.instances {
-                            writeln!(report, "- Name: {}", instance_name).unwrap();
+                            writeln!(report, "- Name: {instance_name}").unwrap();
                             writeln!(report, "- Reference count: {}", instance.strong_count())
                                 .unwrap();
                             if let Some(instance) = instance.upgrade() {

azalea/examples/testbot/commands/movement.rs

@@ -116,7 +116,7 @@ pub fn register(commands: &mut CommandDispatcher<Mutex<CommandSource>>) {
                         get_integer(ctx, "y").unwrap(),
                         get_integer(ctx, "z").unwrap(),
                     );
-                    println!("{:?}", pos);
+                    println!("{pos:?}");
                     let source = ctx.source.lock();
                     source.bot.look_at(pos.center());
                     1

azalea/examples/testbot/killaura.rs

@@ -39,8 +39,8 @@ pub fn tick(bot: Client, state: State) -> anyhow::Result<()> {
         }
     }
     if let Some(nearest_entity) = nearest_entity {
-        println!("attacking {:?}", nearest_entity);
-        println!("distance {:?}", nearest_distance);
+        println!("attacking {nearest_entity:?}");
+        println!("distance {nearest_distance:?}");
         bot.attack(nearest_entity);
     }
 

azalea/examples/testbot/main.rs

@@ -241,7 +241,7 @@ fn parse_args() -> Args {
                 pathfinder_debug_particles = true;
             }
             _ => {
-                eprintln!("Unknown argument: {}", arg);
+                eprintln!("Unknown argument: {arg}");
                 process::exit(1);
             }
         }

azalea/src/auto_tool.rs

@@ -95,11 +95,11 @@ pub fn accurate_best_tool_in_hotbar_for_block(
                 }
             }
         }
-        if let Some(this_item_speed) = this_item_speed {
-            if this_item_speed > best_speed {
-                best_slot = Some(i);
-                best_speed = this_item_speed;
-            }
+        if let Some(this_item_speed) = this_item_speed
+            && this_item_speed > best_speed
+        {
+            best_slot = Some(i);
+            best_speed = this_item_speed;
         }
     }
 

azalea/src/pathfinder/mod.rs

@@ -715,12 +715,12 @@ pub fn check_node_reached(
                             direction: WalkDirection::None,
                         });
                         commands.entity(entity).remove::<ExecutingPath>();
-                        if let Some(goal) = pathfinder.goal.clone() {
-                            if goal.success(movement.target) {
-                                info!("goal was reached!");
-                                pathfinder.goal = None;
-                                pathfinder.successors_fn = None;
-                            }
+                        if let Some(goal) = pathfinder.goal.clone()
+                            && goal.success(movement.target)
+                        {
+                            info!("goal was reached!");
+                            pathfinder.goal = None;
+                            pathfinder.successors_fn = None;
                         }
                     }
 
@@ -875,17 +875,17 @@ fn patch_path(
 
     let mut is_patch_complete = false;
     if let Some(path_found_event) = path_found_event {
-        if let Some(found_path_patch) = path_found_event.path {
-            if !found_path_patch.is_empty() {
-                new_path.extend(found_path_patch);
+        if let Some(found_path_patch) = path_found_event.path
+            && !found_path_patch.is_empty()
+        {
+            new_path.extend(found_path_patch);
 
-                if !path_found_event.is_partial {
-                    new_path.extend(executing_path.path.iter().skip(*patch_nodes.end()).cloned());
-                    is_patch_complete = true;
-                    debug!("the patch is not partial :)");
-                } else {
-                    debug!("the patch is partial, throwing away rest of path :(");
-                }
+            if !path_found_event.is_partial {
+                new_path.extend(executing_path.path.iter().skip(*patch_nodes.end()).cloned());
+                is_patch_complete = true;
+                debug!("the patch is not partial :)");
+            } else {
+                debug!("the patch is partial, throwing away rest of path :(");
             }
         }
     } else {
@@ -1028,19 +1028,20 @@ pub fn recalculate_if_has_goal_but_no_path(
     mut goto_events: EventWriter<GotoEvent>,
 ) {
     for (entity, mut pathfinder) in &mut query {
-        if pathfinder.goal.is_some() && !pathfinder.is_calculating {
-            if let Some(goal) = pathfinder.goal.as_ref().cloned() {
-                debug!("Recalculating path because it has a goal but no ExecutingPath");
-                goto_events.write(GotoEvent {
-                    entity,
-                    goal,
-                    successors_fn: pathfinder.successors_fn.unwrap(),
-                    allow_mining: pathfinder.allow_mining,
-                    min_timeout: pathfinder.min_timeout.expect("min_timeout should be set"),
-                    max_timeout: pathfinder.max_timeout.expect("max_timeout should be set"),
-                });
-                pathfinder.is_calculating = true;
-            }
+        if pathfinder.goal.is_some()
+            && !pathfinder.is_calculating
+            && let Some(goal) = pathfinder.goal.as_ref().cloned()
+        {
+            debug!("Recalculating path because it has a goal but no ExecutingPath");
+            goto_events.write(GotoEvent {
+                entity,
+                goal,
+                successors_fn: pathfinder.successors_fn.unwrap(),
+                allow_mining: pathfinder.allow_mining,
+                min_timeout: pathfinder.min_timeout.expect("min_timeout should be set"),
+                max_timeout: pathfinder.max_timeout.expect("max_timeout should be set"),
+            });
+            pathfinder.is_calculating = true;
         }
     }
 }

azalea/src/pathfinder/moves/basic.rs

@@ -173,10 +173,10 @@ fn execute_ascend_move(mut ctx: ExecuteCtx) {
             (-1, 0) => Some(properties::FacingCardinal::West),
             _ => None,
         };
-        if let Some(expected_stair_facing) = expected_stair_facing {
-            if stair_facing == expected_stair_facing {
-                return;
-            }
+        if let Some(expected_stair_facing) = expected_stair_facing
+            && stair_facing == expected_stair_facing
+        {
+            return;
         }
     }
 

azalea/src/pathfinder/world.rs

@@ -47,10 +47,10 @@ impl CachedSections {
         if let Some(last_item) = self.sections.get(self.last_index) {
             if last_item.pos == pos {
                 return Some(&mut self.sections[self.last_index]);
-            } else if let Some(second_last_item) = self.sections.get(self.second_last_index) {
-                if second_last_item.pos == pos {
-                    return Some(&mut self.sections[self.second_last_index]);
-                }
+            } else if let Some(second_last_item) = self.sections.get(self.second_last_index)
+                && second_last_item.pos == pos
+            {
+                return Some(&mut self.sections[self.second_last_index]);
             }
         }
 
@@ -134,17 +134,17 @@ impl CachedWorld {
 
         // optimization: avoid doing the iter lookup if the last chunk we looked up is
         // the same
-        if let Some(last_chunk_cache_index) = *self.last_chunk_cache_index.borrow() {
-            if cached_chunks[last_chunk_cache_index].0 == chunk_pos {
-                // don't bother with the iter lookup
-                let sections = &cached_chunks[last_chunk_cache_index].1;
-                if section_index >= sections.len() {
-                    // y position is out of bounds
-                    return None;
-                };
-                let section: &azalea_world::palette::PalettedContainer = &sections[section_index];
-                return Some(f(section));
-            }
+        if let Some(last_chunk_cache_index) = *self.last_chunk_cache_index.borrow()
+            && cached_chunks[last_chunk_cache_index].0 == chunk_pos
+        {
+            // don't bother with the iter lookup
+            let sections = &cached_chunks[last_chunk_cache_index].1;
+            if section_index >= sections.len() {
+                // y position is out of bounds
+                return None;
+            };
+            let section: &azalea_world::palette::PalettedContainer = &sections[section_index];
+            return Some(f(section));
         }
 
         // get section from cache