Run clippy on CI

Fixes #1402.
rust-windowing · Jun 7, 2022 · d0bce5a · d0bce5a
1 parent 9253029
commit d0bce5a
Show file tree

Hide file tree

Showing 57 changed files with 405 additions and 404 deletions.
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
@@ -17,7 +17,8 @@ jobs:
     - name: Check Formatting
       run: cargo +stable fmt --all -- --check
 
-  Tests:
+  tests:
+    name: Tests
     strategy:
       fail-fast: false
       matrix:
@@ -62,6 +63,7 @@ jobs:
       with:
         rust-version: ${{ matrix.rust_version }}${{ matrix.platform.host }}
         targets: ${{ matrix.platform.target }}
+        components: clippy
 
     - name: Install Linux dependencies
       if: (matrix.platform.os == 'ubuntu-latest')
@@ -93,6 +95,10 @@ jobs:
         !contains(matrix.platform.target, 'wasm32'))
       run: cargo $CMD test --verbose --target ${{ matrix.platform.target }} $OPTIONS --features $FEATURES
 
+    - name: Lint with clippy
+      shell: bash
+      if: (matrix.rust_version != 'nightly') && !contains(matrix.platform.options, '--no-default-features')
+      run: cargo clippy --all-targets --target ${{ matrix.platform.target }} $OPTIONS --features $FEATURES
 
     - name: Build with serde enabled
       shell: bash

diff --git a/examples/fullscreen.rs b/examples/fullscreen.rs
@@ -34,8 +34,8 @@ fn main() {
     event_loop.run(move |event, _, control_flow| {
         control_flow.set_wait();
 
-        match event {
-            Event::WindowEvent { event, .. } => match event {
+        if let Event::WindowEvent { event, .. } = event {
+            match event {
                 WindowEvent::CloseRequested => control_flow.set_exit(),
                 WindowEvent::KeyboardInput {
                     input:
@@ -68,8 +68,7 @@ fn main() {
                     _ => (),
                 },
                 _ => (),
-            },
-            _ => {}
+            }
         }
     });
 }

diff --git a/examples/handling_close.rs b/examples/handling_close.rs
@@ -23,62 +23,59 @@ fn main() {
         };
         control_flow.set_wait();
 
-        match event {
-            Event::WindowEvent { event, .. } => {
-                match event {
-                    WindowEvent::CloseRequested => {
-                        // `CloseRequested` is sent when the close button on the window is pressed (or
-                        // through whatever other mechanisms the window manager provides for closing a
-                        // window). If you don't handle this event, the close button won't actually do
-                        // anything.
+        if let Event::WindowEvent { event, .. } = event {
+            match event {
+                WindowEvent::CloseRequested => {
+                    // `CloseRequested` is sent when the close button on the window is pressed (or
+                    // through whatever other mechanisms the window manager provides for closing a
+                    // window). If you don't handle this event, the close button won't actually do
+                    // anything.
 
-                        // A common thing to do here is prompt the user if they have unsaved work.
-                        // Creating a proper dialog box for that is far beyond the scope of this
-                        // example, so here we'll just respond to the Y and N keys.
-                        println!("Are you ready to bid your window farewell? [Y/N]");
-                        close_requested = true;
+                    // A common thing to do here is prompt the user if they have unsaved work.
+                    // Creating a proper dialog box for that is far beyond the scope of this
+                    // example, so here we'll just respond to the Y and N keys.
+                    println!("Are you ready to bid your window farewell? [Y/N]");
+                    close_requested = true;
 
-                        // In applications where you can safely close the window without further
-                        // action from the user, this is generally where you'd handle cleanup before
-                        // closing the window. How to close the window is detailed in the handler for
-                        // the Y key.
-                    }
-                    WindowEvent::KeyboardInput {
-                        input:
-                            KeyboardInput {
-                                virtual_keycode: Some(virtual_code),
-                                state: Released,
-                                ..
-                            },
-                        ..
-                    } => {
-                        match virtual_code {
-                            Y => {
-                                if close_requested {
-                                    // This is where you'll want to do any cleanup you need.
-                                    println!("Buh-bye!");
+                    // In applications where you can safely close the window without further
+                    // action from the user, this is generally where you'd handle cleanup before
+                    // closing the window. How to close the window is detailed in the handler for
+                    // the Y key.
+                }
+                WindowEvent::KeyboardInput {
+                    input:
+                        KeyboardInput {
+                            virtual_keycode: Some(virtual_code),
+                            state: Released,
+                            ..
+                        },
+                    ..
+                } => {
+                    match virtual_code {
+                        Y => {
+                            if close_requested {
+                                // This is where you'll want to do any cleanup you need.
+                                println!("Buh-bye!");
 
-                                    // For a single-window application like this, you'd normally just
-                                    // break out of the event loop here. If you wanted to keep running the
-                                    // event loop (i.e. if it's a multi-window application), you need to
-                                    // drop the window. That closes it, and results in `Destroyed` being
-                                    // sent.
-                                    control_flow.set_exit();
-                                }
+                                // For a single-window application like this, you'd normally just
+                                // break out of the event loop here. If you wanted to keep running the
+                                // event loop (i.e. if it's a multi-window application), you need to
+                                // drop the window. That closes it, and results in `Destroyed` being
+                                // sent.
+                                control_flow.set_exit();
                             }
-                            N => {
-                                if close_requested {
-                                    println!("Your window will continue to stay by your side.");
-                                    close_requested = false;
-                                }
+                        }
+                        N => {
+                            if close_requested {
+                                println!("Your window will continue to stay by your side.");
+                                close_requested = false;
                             }
-                            _ => (),
                         }
+                        _ => (),
                     }
-                    _ => (),
                 }
+                _ => (),
             }
-            _ => (),
         }
     });
 }
diff --git a/examples/min_max_size.rs b/examples/min_max_size.rs
@@ -19,12 +19,12 @@ fn main() {
         control_flow.set_wait();
         println!("{:?}", event);
 
-        match event {
-            Event::WindowEvent {
-                event: WindowEvent::CloseRequested,
-                ..
-            } => control_flow.set_exit(),
-            _ => (),
+        if let Event::WindowEvent {
+            event: WindowEvent::CloseRequested,
+            ..
+        } = event
+        {
+            control_flow.set_exit()
         }
     });
 }
diff --git a/examples/mouse_wheel.rs b/examples/mouse_wheel.rs
@@ -32,8 +32,8 @@ In other words, the deltas indicate the direction in which to move the content (
     event_loop.run(move |event, _, control_flow| {
         control_flow.set_wait();
 
-        match event {
-            Event::WindowEvent { event, .. } => match event {
+        if let Event::WindowEvent { event, .. } = event {
+            match event {
                 WindowEvent::CloseRequested => control_flow.set_exit(),
                 WindowEvent::MouseWheel { delta, .. } => match delta {
                     winit::event::MouseScrollDelta::LineDelta(x, y) => {
@@ -53,8 +53,7 @@ In other words, the deltas indicate the direction in which to move the content (
                     }
                 },
                 _ => (),
-            },
-            _ => (),
+            }
         }
     });
 }
diff --git a/examples/multithreaded.rs b/examples/multithreaded.rs
@@ -147,8 +147,9 @@ fn main() {
             true => control_flow.set_wait(),
             false => control_flow.set_exit(),
         };
-        match event {
-            Event::WindowEvent { event, window_id } => match event {
+
+        if let Event::WindowEvent { event, window_id } = event {
+            match event {
                 WindowEvent::CloseRequested
                 | WindowEvent::Destroyed
                 | WindowEvent::KeyboardInput {
@@ -169,8 +170,7 @@ fn main() {
                         }
                     }
                 }
-            },
-            _ => {}
+            }
         }
     })
 }

diff --git a/examples/multiwindow.rs b/examples/multiwindow.rs
@@ -20,34 +20,31 @@ fn main() {
     event_loop.run(move |event, event_loop, control_flow| {
         control_flow.set_wait();
 
-        match event {
-            Event::WindowEvent { event, window_id } => {
-                match event {
-                    WindowEvent::CloseRequested => {
-                        println!("Window {:?} has received the signal to close", window_id);
+        if let Event::WindowEvent { event, window_id } = event {
+            match event {
+                WindowEvent::CloseRequested => {
+                    println!("Window {:?} has received the signal to close", window_id);
 
-                        // This drops the window, causing it to close.
-                        windows.remove(&window_id);
+                    // This drops the window, causing it to close.
+                    windows.remove(&window_id);
 
-                        if windows.is_empty() {
-                            control_flow.set_exit();
-                        }
+                    if windows.is_empty() {
+                        control_flow.set_exit();
                     }
-                    WindowEvent::KeyboardInput {
-                        input:
-                            KeyboardInput {
-                                state: ElementState::Pressed,
-                                ..
-                            },
-                        ..
-                    } => {
-                        let window = Window::new(event_loop).unwrap();
-                        windows.insert(window.id(), window);
-                    }
-                    _ => (),
                 }
+                WindowEvent::KeyboardInput {
+                    input:
+                        KeyboardInput {
+                            state: ElementState::Pressed,
+                            ..
+                        },
+                    ..
+                } => {
+                    let window = Window::new(event_loop).unwrap();
+                    windows.insert(window.id(), window);
+                }
+                _ => (),
             }
-            _ => (),
         }
     })
 }
diff --git a/examples/request_redraw_threaded.rs b/examples/request_redraw_threaded.rs
@@ -28,10 +28,9 @@ fn main() {
         control_flow.set_wait();
 
         match event {
-            Event::WindowEvent { event, .. } => match event {
-                WindowEvent::CloseRequested => control_flow.set_exit(),
-                _ => (),
-            },
+            Event::WindowEvent { event, .. } if event == WindowEvent::CloseRequested => {
+                control_flow.set_exit()
+            }
             Event::RedrawRequested(_) => {
                 println!("\nredrawing!\n");
             }

diff --git a/examples/resizable.rs b/examples/resizable.rs
@@ -22,8 +22,8 @@ fn main() {
     event_loop.run(move |event, _, control_flow| {
         control_flow.set_wait();
 
-        match event {
-            Event::WindowEvent { event, .. } => match event {
+        if let Event::WindowEvent { event, .. } = event {
+            match event {
                 WindowEvent::CloseRequested => control_flow.set_exit(),
                 WindowEvent::KeyboardInput {
                     input:
@@ -39,8 +39,7 @@ fn main() {
                     window.set_resizable(resizable);
                 }
                 _ => (),
-            },
-            _ => (),
-        };
+            }
+        }
     });
 }
diff --git a/examples/transparent.rs b/examples/transparent.rs
@@ -21,12 +21,12 @@ fn main() {
         control_flow.set_wait();
         println!("{:?}", event);
 
-        match event {
-            Event::WindowEvent {
-                event: WindowEvent::CloseRequested,
-                ..
-            } => control_flow.set_exit(),
-            _ => (),
+        if let Event::WindowEvent {
+            event: WindowEvent::CloseRequested,
+            ..
+        } = event
+        {
+            control_flow.set_exit()
         }
     });
 }
diff --git a/examples/web.rs b/examples/web.rs
@@ -43,6 +43,7 @@ mod wasm {
     pub fn run() {
         console_log::init_with_level(log::Level::Debug).expect("error initializing logger");
 
+        #[allow(clippy::main_recursion)]
         super::main();
     }