From ddbbcc278e50e0ad6b50bdbf50f80419a6a24c10 Mon Sep 17 00:00:00 2001
From: TornaxO7 <tornax@proton.me>
Date: Mon, 23 Oct 2023 21:52:17 +0200
Subject: [PATCH] make `cargo clippy` happy

---
 examples/hello-windows/src/main.rs | 114 +++++++++++++++--------------
 wgpu-core/src/id.rs                |   2 +-
 wgpu-hal/src/gles/egl.rs           |   2 +-
 3 files changed, 61 insertions(+), 57 deletions(-)

diff --git a/examples/hello-windows/src/main.rs b/examples/hello-windows/src/main.rs
index 08f6f9f09b..43bd986965 100644
--- a/examples/hello-windows/src/main.rs
+++ b/examples/hello-windows/src/main.rs
@@ -95,66 +95,70 @@ async fn run(event_loop: EventLoop<()>, viewports: Vec<(Window, wgpu::Color)>) {
         .map(|desc| (desc.window.id(), desc.build(&adapter, &device)))
         .collect();
 
-    event_loop.run(move |event, target| {
-        // Have the closure take ownership of the resources.
-        // `event_loop.run` never returns, therefore we must do this to ensure
-        // the resources are properly cleaned up.
-        let _ = (&instance, &adapter);
-
-        match event {
-            Event::WindowEvent {
-                window_id, event, ..
-            } => match event {
-                WindowEvent::Resized(new_size) => {
-                    // Recreate the swap chain with the new size
-                    if let Some(viewport) = viewports.get_mut(&window_id) {
-                        viewport.resize(&device, new_size);
-                        // On macos the window needs to be redrawn manually after resizing
-                        viewport.desc.window.request_redraw();
+    event_loop
+        .run(move |event, target| {
+            // Have the closure take ownership of the resources.
+            // `event_loop.run` never returns, therefore we must do this to ensure
+            // the resources are properly cleaned up.
+            let _ = (&instance, &adapter);
+
+            if let Event::WindowEvent { window_id, event } = event {
+                match event {
+                    WindowEvent::Resized(new_size) => {
+                        // Recreate the swap chain with the new size
+                        if let Some(viewport) = viewports.get_mut(&window_id) {
+                            viewport.resize(&device, new_size);
+                            // On macos the window needs to be redrawn manually after resizing
+                            viewport.desc.window.request_redraw();
+                        }
                     }
-                }
-                WindowEvent::RedrawRequested => {
-                    if let Some(viewport) = viewports.get_mut(&window_id) {
-                        let frame = viewport.get_current_texture();
-                        let view = frame
-                            .texture
-                            .create_view(&wgpu::TextureViewDescriptor::default());
-                        let mut encoder =
-                            device.create_command_encoder(&wgpu::CommandEncoderDescriptor {
-                                label: None,
-                            });
-                        {
-                            let _rpass = encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
-                                label: None,
-                                color_attachments: &[Some(wgpu::RenderPassColorAttachment {
-                                    view: &view,
-                                    resolve_target: None,
-                                    ops: wgpu::Operations {
-                                        load: wgpu::LoadOp::Clear(viewport.desc.background),
-                                        store: wgpu::StoreOp::Store,
-                                    },
-                                })],
-                                depth_stencil_attachment: None,
-                                timestamp_writes: None,
-                                occlusion_query_set: None,
-                            });
+                    WindowEvent::RedrawRequested => {
+                        if let Some(viewport) = viewports.get_mut(&window_id) {
+                            let frame = viewport.get_current_texture();
+                            let view = frame
+                                .texture
+                                .create_view(&wgpu::TextureViewDescriptor::default());
+                            let mut encoder =
+                                device.create_command_encoder(&wgpu::CommandEncoderDescriptor {
+                                    label: None,
+                                });
+                            {
+                                let _rpass =
+                                    encoder.begin_render_pass(&wgpu::RenderPassDescriptor {
+                                        label: None,
+                                        color_attachments: &[Some(
+                                            wgpu::RenderPassColorAttachment {
+                                                view: &view,
+                                                resolve_target: None,
+                                                ops: wgpu::Operations {
+                                                    load: wgpu::LoadOp::Clear(
+                                                        viewport.desc.background,
+                                                    ),
+                                                    store: wgpu::StoreOp::Store,
+                                                },
+                                            },
+                                        )],
+                                        depth_stencil_attachment: None,
+                                        timestamp_writes: None,
+                                        occlusion_query_set: None,
+                                    });
+                            }
+
+                            queue.submit(Some(encoder.finish()));
+                            frame.present();
                         }
-
-                        queue.submit(Some(encoder.finish()));
-                        frame.present();
                     }
-                }
-                WindowEvent::CloseRequested => {
-                    viewports.remove(&window_id);
-                    if viewports.is_empty() {
-                        target.exit();
+                    WindowEvent::CloseRequested => {
+                        viewports.remove(&window_id);
+                        if viewports.is_empty() {
+                            target.exit();
+                        }
                     }
+                    _ => {}
                 }
-                _ => {}
-            },
-            _ => {}
-        }
-    }).unwrap();
+            }
+        })
+        .unwrap();
 }
 
 fn main() {
diff --git a/wgpu-core/src/id.rs b/wgpu-core/src/id.rs
index 2386bfb6e7..d5ad6f218f 100644
--- a/wgpu-core/src/id.rs
+++ b/wgpu-core/src/id.rs
@@ -154,7 +154,7 @@ impl<T> Eq for Id<T> {}
 
 impl<T> PartialOrd for Id<T> {
     fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-        self.0.partial_cmp(&other.0)
+        Some(self.cmp(other))
     }
 }
 
diff --git a/wgpu-hal/src/gles/egl.rs b/wgpu-hal/src/gles/egl.rs
index 6310176d62..8bed6c3166 100644
--- a/wgpu-hal/src/gles/egl.rs
+++ b/wgpu-hal/src/gles/egl.rs
@@ -1166,7 +1166,7 @@ impl crate::Surface<super::Api> for Surface {
                             unsafe { library.get(b"wl_egl_window_create") }.unwrap();
                         let window =
                             unsafe { wl_egl_window_create(handle.surface.as_ptr(), 640, 480) }
-                                as *mut _ as *mut std::ffi::c_void;
+                                as *mut _;
                         wl_window = Some(window);
                         window
                     }