Apply Clippy lints regarding lazy evaluation and closures (#14015)

# Objective

- Lazily evaluate
[default](https://rust-lang.github.io/rust-clippy/master/index.html#/unwrap_or_default)~~/[or](https://rust-lang.github.io/rust-clippy/master/index.html#/or_fun_call)~~
values where it makes sense
  - ~~`unwrap_or(foo())` -> `unwrap_or_else(|| foo())`~~
  - `unwrap_or(Default::default())` -> `unwrap_or_default()`
  - etc.
- Avoid creating [redundant
closures](https://rust-lang.github.io/rust-clippy/master/index.html#/redundant_closure),
even for [method
calls](https://rust-lang.github.io/rust-clippy/master/index.html#/redundant_closure_for_method_calls)
  - `map(|something| something.into())` -> `map(Into:into)`

## Solution

- Apply Clippy lints:
-
~~[or_fun_call](https://rust-lang.github.io/rust-clippy/master/index.html#/or_fun_call)~~
-
[unwrap_or_default](https://rust-lang.github.io/rust-clippy/master/index.html#/unwrap_or_default)
-
[redundant_closure_for_method_calls](https://rust-lang.github.io/rust-clippy/master/index.html#/redundant_closure_for_method_calls)
([redundant
closures](https://rust-lang.github.io/rust-clippy/master/index.html#/redundant_closure)
is already enabled)

## Testing

- Tested on Windows 11 (`stable-x86_64-pc-windows-gnu`, 1.79.0)
- Bevy compiles without errors or warnings and examples seem to work as
intended
  - `cargo clippy` ✅
  - `cargo run -p ci -- compile` ✅

---------

Co-authored-by: Alice Cecile <alice.i.cecile@gmail.com>

Author: Luracasmus

Cargo.toml

@@ -38,6 +38,8 @@ undocumented_unsafe_blocks = "warn"
 redundant_else = "warn"
 match_same_arms = "warn"
 semicolon_if_nothing_returned = "warn"
+redundant_closure_for_method_calls = "warn"
+unwrap_or_default = "warn"
 
 ptr_as_ptr = "warn"
 ptr_cast_constness = "warn"

crates/bevy_animation/src/lib.rs

@@ -612,15 +612,15 @@ impl AnimationPlayer {
     pub fn all_finished(&self) -> bool {
         self.active_animations
             .values()
-            .all(|playing_animation| playing_animation.is_finished())
+            .all(ActiveAnimation::is_finished)
     }
 
     /// Check if all playing animations are paused.
     #[doc(alias = "is_paused")]
     pub fn all_paused(&self) -> bool {
         self.active_animations
             .values()
-            .all(|playing_animation| playing_animation.is_paused())
+            .all(ActiveAnimation::is_paused)
     }
 
     /// Resume all playing animations.

crates/bevy_app/src/app.rs

@@ -242,7 +242,7 @@ impl App {
         let main = self.main_mut();
         main.plugin_registry = plugins;
         main.plugins_state = PluginsState::Finished;
-        self.sub_apps.iter_mut().skip(1).for_each(|s| s.finish());
+        self.sub_apps.iter_mut().skip(1).for_each(SubApp::finish);
     }
 
     /// Runs [`Plugin::cleanup`] for each plugin. This is usually called by the event loop after
@@ -256,12 +256,12 @@ impl App {
         let main = self.main_mut();
         main.plugin_registry = plugins;
         main.plugins_state = PluginsState::Cleaned;
-        self.sub_apps.iter_mut().skip(1).for_each(|s| s.cleanup());
+        self.sub_apps.iter_mut().skip(1).for_each(SubApp::cleanup);
     }
 
     /// Returns `true` if any of the sub-apps are building plugins.
     pub(crate) fn is_building_plugins(&self) -> bool {
-        self.sub_apps.iter().any(|s| s.is_building_plugins())
+        self.sub_apps.iter().any(SubApp::is_building_plugins)
     }
 
     /// Adds one or more systems to the given schedule in this app's [`Schedules`].

crates/bevy_asset/src/io/file/mod.rs

@@ -22,11 +22,7 @@ pub(crate) fn get_base_path() -> PathBuf {
         PathBuf::from(manifest_dir)
     } else {
         env::current_exe()
-            .map(|path| {
-                path.parent()
-                    .map(|exe_parent_path| exe_parent_path.to_owned())
-                    .unwrap()
-            })
+            .map(|path| path.parent().map(ToOwned::to_owned).unwrap())
             .unwrap()
     }
 }

crates/bevy_asset/src/loader.rs

@@ -93,7 +93,7 @@ where
                 .expect("AssetLoader settings should match the loader type");
             let asset = <L as AssetLoader>::load(self, reader, settings, &mut load_context)
                 .await
-                .map_err(|error| error.into())?;
+                .map_err(Into::into)?;
             Ok(load_context.finish(asset, Some(meta)).into())
         })
     }
@@ -540,7 +540,7 @@ impl<'a> LoadContext<'a> {
             .meta
             .as_ref()
             .and_then(|m| m.processed_info().as_ref());
-        let hash = info.map(|i| i.full_hash).unwrap_or(Default::default());
+        let hash = info.map(|i| i.full_hash).unwrap_or_default();
         self.loader_dependencies.insert(path, hash);
         Ok(loaded_asset)
     }

crates/bevy_asset/src/path.rs

@@ -320,7 +320,7 @@ impl<'a> AssetPath<'a> {
         AssetPath {
             source: self.source.into_owned(),
             path: self.path.into_owned(),
-            label: self.label.map(|l| l.into_owned()),
+            label: self.label.map(CowArc::into_owned),
         }
     }
 

crates/bevy_asset/src/reflect.rs

@@ -3,7 +3,7 @@ use std::any::{Any, TypeId};
 use bevy_ecs::world::{unsafe_world_cell::UnsafeWorldCell, World};
 use bevy_reflect::{FromReflect, FromType, Reflect};
 
-use crate::{Asset, Assets, Handle, UntypedAssetId, UntypedHandle};
+use crate::{Asset, AssetId, Assets, Handle, UntypedAssetId, UntypedHandle};
 
 /// Type data for the [`TypeRegistry`](bevy_reflect::TypeRegistry) used to operate on reflected [`Asset`]s.
 ///
@@ -160,7 +160,7 @@ impl<A: Asset + FromReflect> FromType<A> for ReflectAsset {
             },
             ids: |world| {
                 let assets = world.resource::<Assets<A>>();
-                Box::new(assets.ids().map(|i| i.untyped()))
+                Box::new(assets.ids().map(AssetId::untyped))
             },
             remove: |world, handle| {
                 let mut assets = world.resource_mut::<Assets<A>>();

crates/bevy_asset/src/server/loaders.rs

@@ -212,7 +212,7 @@ impl AssetLoaders {
         }
 
         // Try extracting the extension from the path
-        if let Some(full_extension) = asset_path.and_then(|path| path.get_full_extension()) {
+        if let Some(full_extension) = asset_path.and_then(AssetPath::get_full_extension) {
             if let Some(&index) = try_extension(full_extension.as_str()) {
                 return self.get_by_index(index);
             }

crates/bevy_asset/src/server/mod.rs

@@ -230,7 +230,7 @@ impl AssetServer {
 
             let mut extensions = vec![full_extension.clone()];
             extensions.extend(
-                AssetPath::iter_secondary_extensions(&full_extension).map(|e| e.to_string()),
+                AssetPath::iter_secondary_extensions(&full_extension).map(ToString::to_string),
             );
 
             MissingAssetLoaderForExtensionError { extensions }
@@ -493,7 +493,7 @@ impl AssetServer {
         force: bool,
         meta_transform: Option<MetaTransform>,
     ) -> Result<UntypedHandle, AssetLoadError> {
-        let asset_type_id = input_handle.as_ref().map(|handle| handle.type_id());
+        let asset_type_id = input_handle.as_ref().map(UntypedHandle::type_id);
 
         let path = path.into_owned();
         let path_clone = path.clone();
@@ -938,7 +938,7 @@ impl AssetServer {
     /// or is still "alive".
     pub fn get_handle<'a, A: Asset>(&self, path: impl Into<AssetPath<'a>>) -> Option<Handle<A>> {
         self.get_path_and_type_id_handle(&path.into(), TypeId::of::<A>())
-            .map(|h| h.typed_debug_checked())
+            .map(UntypedHandle::typed_debug_checked)
     }
 
     /// Get a `Handle` from an `AssetId`.
@@ -949,7 +949,8 @@ impl AssetServer {
     /// Consider using [`Assets::get_strong_handle`] in the case the `Handle`
     /// comes from [`Assets::add`].
     pub fn get_id_handle<A: Asset>(&self, id: AssetId<A>) -> Option<Handle<A>> {
-        self.get_id_handle_untyped(id.untyped()).map(|h| h.typed())
+        self.get_id_handle_untyped(id.untyped())
+            .map(UntypedHandle::typed)
     }
 
     /// Get an `UntypedHandle` from an `UntypedAssetId`.

crates/bevy_core_pipeline/src/skybox/mod.rs

@@ -99,7 +99,7 @@ impl ExtractComponent for Skybox {
 
     fn extract_component((skybox, exposure): QueryItem<'_, Self::QueryData>) -> Option<Self::Out> {
         let exposure = exposure
-            .map(|e| e.exposure())
+            .map(Exposure::exposure)
             .unwrap_or_else(|| Exposure::default().exposure());
 
         Some((