fix clippy lints (#1756)

crates/bevy_app/src/event.rs

@@ -276,7 +276,7 @@ impl<T: Component> Events<T> {
         };
         trace!("Events::send() -> {}", event_id);
 
-        let event_instance = EventInstance { event, event_id };
+        let event_instance = EventInstance { event_id, event };
 
         match self.state {
             State::A => self.events_a.push(event_instance),

crates/bevy_asset/src/loader.rs

@@ -64,10 +64,9 @@ pub(crate) struct BoxedLoadedAsset {
 impl<T: Asset> From<LoadedAsset<T>> for BoxedLoadedAsset {
     fn from(asset: LoadedAsset<T>) -> Self {
         BoxedLoadedAsset {
-            value: match asset.value {
+            value: asset
-                Some(value) => Some(Box::new(value)),
+                .value
-                None => None,
+                .map(|value| Box::new(value) as Box<dyn AssetDynamic>),
-            },
             dependencies: asset.dependencies,
         }
     }

crates/bevy_ecs/macros/src/lib.rs

@@ -28,8 +28,7 @@ impl Parse for AllTuples {
         input.parse::<Comma>()?;
         let end = input.parse::<LitInt>()?.base10_parse()?;
         input.parse::<Comma>()?;
-        let mut idents = Vec::new();
+        let mut idents = vec![input.parse::<Ident>()?];
-        idents.push(input.parse::<Ident>()?);
         while input.parse::<Comma>().is_ok() {
             idents.push(input.parse::<Ident>()?);
         }

crates/bevy_reflect/src/struct_trait.rs

@@ -109,11 +109,9 @@ impl DynamicStruct {
 impl Struct for DynamicStruct {
     #[inline]
     fn field(&self, name: &str) -> Option<&dyn Reflect> {
-        if let Some(index) = self.field_indices.get(name) {
+        self.field_indices
-            Some(&*self.fields[*index])
+            .get(name)
-        } else {
+            .map(|index| &*self.fields[*index])
-            None
-        }
     }
 
     #[inline]

crates/bevy_render/src/pipeline/pipeline_compiler.rs

@@ -284,15 +284,13 @@ impl PipelineCompiler {
         &self,
         pipeline_handle: Handle<PipelineDescriptor>,
     ) -> Option<impl Iterator<Item = &Handle<PipelineDescriptor>>> {
-        if let Some(compiled_pipelines) = self.specialized_pipelines.get(&pipeline_handle) {
+        self.specialized_pipelines
-            Some(
+            .get(&pipeline_handle)
+            .map(|compiled_pipelines| {
                 compiled_pipelines
                     .iter()
-                    .map(|specialized_pipeline| &specialized_pipeline.pipeline),
+                    .map(|specialized_pipeline| &specialized_pipeline.pipeline)
-            )
+            })
-        } else {
-            None
-        }
     }
 
     pub fn iter_all_compiled_pipelines(&self) -> impl Iterator<Item = &Handle<PipelineDescriptor>> {

crates/bevy_render/src/render_graph/nodes/render_resources_node.rs

@@ -202,22 +202,18 @@ where
         render_resource_context: &dyn RenderResourceContext,
     ) -> bool {
         let mut resized = false;
-        for buffer_array in self.buffer_arrays.iter_mut() {
+        for buffer_array in self.buffer_arrays.iter_mut().flatten() {
-            if let Some(buffer_array) = buffer_array {
             resized |= buffer_array.resize(render_resource_context);
         }
-        }
 
         resized
     }
 
     fn set_required_staging_buffer_size_to_max(&mut self) {
         let mut new_size = 0;
-        for buffer_array in self.buffer_arrays.iter() {
+        for buffer_array in self.buffer_arrays.iter().flatten() {
-            if let Some(buffer_array) = buffer_array {
             new_size += buffer_array.item_size * buffer_array.len;
         }
-        }
 
         if new_size > self.required_staging_buffer_size {
             self.required_staging_buffer_size = new_size;
@@ -248,12 +244,10 @@ where
     }
 
     fn remove_bindings(&mut self, id: I) {
-        for buffer_array in self.buffer_arrays.iter_mut() {
+        for buffer_array in self.buffer_arrays.iter_mut().flatten() {
-            if let Some(buffer_array) = buffer_array {
             buffer_array.remove_binding(id);
         }
     }
-    }
 
     fn write_uniform_buffers(
         &mut self,

crates/bevy_render/src/shader/shader.rs

@@ -142,7 +142,7 @@ pub struct Shader {
 
 impl Shader {
     pub fn new(stage: ShaderStage, source: ShaderSource) -> Shader {
-        Shader { stage, source }
+        Shader { source, stage }
     }
 
     #[cfg(not(target_arch = "wasm32"))]

crates/bevy_render/src/texture/texture.rs

@@ -56,8 +56,8 @@ impl Texture {
         Self {
             data,
             size,
-            dimension,
             format,
+            dimension,
             ..Default::default()
         }
     }

crates/bevy_transform/src/components/global_transform.rs

@@ -144,9 +144,9 @@ impl GlobalTransform {
         let rotation = self.rotation * transform.rotation;
         let scale = self.scale * transform.scale;
         GlobalTransform {
-            scale,
-            rotation,
             translation,
+            rotation,
+            scale,
         }
     }
 

crates/bevy_transform/src/components/transform.rs

@@ -156,9 +156,9 @@ impl Transform {
         let rotation = self.rotation * transform.rotation;
         let scale = self.scale * transform.scale;
         Transform {
-            scale,
-            rotation,
             translation,
+            rotation,
+            scale,
         }
     }
 

crates/bevy_wgpu/src/renderer/wgpu_render_resource_context.rs

@@ -476,10 +476,11 @@ impl RenderResourceContext for WgpuRenderResourceContext {
             .get(&pipeline_descriptor.shader_stages.vertex)
             .unwrap();
 
-        let fragment_shader_module = match pipeline_descriptor.shader_stages.fragment {
+        let fragment_shader_module = pipeline_descriptor
-            Some(ref fragment_handle) => Some(shader_modules.get(fragment_handle).unwrap()),
+            .shader_stages
-            None => None,
+            .fragment
-        };
+            .as_ref()
+            .map(|fragment_handle| shader_modules.get(fragment_handle).unwrap());
         let render_pipeline_descriptor = wgpu::RenderPipelineDescriptor {
             label: None,
             layout: Some(&pipeline_layout),
@@ -491,14 +492,15 @@ impl RenderResourceContext for WgpuRenderResourceContext {
                     .map(|v| v.into())
                     .collect::<Vec<wgpu::VertexBufferLayout>>(),
             },
-            fragment: match pipeline_descriptor.shader_stages.fragment {
+            fragment: pipeline_descriptor
-                Some(_) => Some(wgpu::FragmentState {
+                .shader_stages
+                .fragment
+                .as_ref()
+                .map(|_| wgpu::FragmentState {
                     entry_point: "main",
                     module: fragment_shader_module.as_ref().unwrap(),
                     targets: color_states.as_slice(),
                 }),
-                None => None,
-            },
             primitive: pipeline_descriptor.primitive.clone().wgpu_into(),
             depth_stencil: pipeline_descriptor
                 .depth_stencil