Run clippy on CI

.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 -- -Dwarnings
 
     - name: Build with serde enabled
       shell: bash

CHANGELOG.md

@@ -53,6 +53,8 @@ And please only add new entries to the top of this list, right below the `# Unre
 - **Breaking:** IME input on desktop platforms won't be received unless it's explicitly allowed via `Window::set_ime_allowed` and new `WindowEvent::Ime` events are handled.
 - On macOS, `WindowEvent::Resized` is now emitted in `frameDidChange` instead of `windowDidResize`.
 - **Breaking:** On X11, device events are now ignored for unfocused windows by default, use `EventLoopWindowTarget::set_device_event_filter` to set the filter level.
+- Implemented `Default` on `EventLoop<()>`.
+- Implemented `Eq` for `Fullscreen`, `Theme`, and `UserAttentionType`.
 
 # 0.26.1 (2022-01-05)
 

examples/control_flow.rs

@@ -1,3 +1,5 @@
+#![allow(clippy::single_match)]
+
 use std::{thread, time};
 
 use simple_logger::SimpleLogger;

examples/cursor.rs

@@ -1,3 +1,5 @@
+#![allow(clippy::single_match)]
+
 use simple_logger::SimpleLogger;
 use winit::{
     event::{ElementState, Event, KeyboardInput, WindowEvent},

examples/cursor_grab.rs

@@ -1,3 +1,5 @@
+#![allow(clippy::single_match)]
+
 use simple_logger::SimpleLogger;
 use winit::{
     event::{DeviceEvent, ElementState, Event, KeyboardInput, ModifiersState, WindowEvent},

examples/custom_events.rs

@@ -1,3 +1,5 @@
+#![allow(clippy::single_match)]
+
 #[cfg(not(target_arch = "wasm32"))]
 fn main() {
     use simple_logger::SimpleLogger;

examples/drag_window.rs

@@ -1,3 +1,5 @@
+#![allow(clippy::single_match)]
+
 use simple_logger::SimpleLogger;
 use winit::{
     event::{

examples/fullscreen.rs

@@ -1,3 +1,5 @@
+#![allow(clippy::single_match)]
+
 use std::io::{stdin, stdout, Write};
 
 use simple_logger::SimpleLogger;

examples/handling_close.rs

@@ -1,3 +1,5 @@
+#![allow(clippy::single_match)]
+
 use simple_logger::SimpleLogger;
 use winit::{
     event::{Event, KeyboardInput, WindowEvent},

examples/ime.rs

@@ -1,3 +1,5 @@
+#![allow(clippy::single_match)]
+
 use log::LevelFilter;
 use simple_logger::SimpleLogger;
 use winit::{

examples/min_max_size.rs

@@ -1,3 +1,5 @@
+#![allow(clippy::single_match)]
+
 use simple_logger::SimpleLogger;
 use winit::{
     dpi::LogicalSize,

examples/minimize.rs

@@ -1,4 +1,4 @@
-extern crate winit;
+#![allow(clippy::single_match)]
 
 use simple_logger::SimpleLogger;
 use winit::event::{Event, VirtualKeyCode, WindowEvent};

examples/monitor_list.rs

@@ -1,3 +1,5 @@
+#![allow(clippy::single_match)]
+
 use simple_logger::SimpleLogger;
 use winit::{event_loop::EventLoop, window::WindowBuilder};
 

examples/mouse_wheel.rs

@@ -1,3 +1,5 @@
+#![allow(clippy::single_match)]
+
 use simple_logger::SimpleLogger;
 use winit::{
     event::{Event, WindowEvent},

examples/multithreaded.rs

@@ -1,3 +1,5 @@
+#![allow(clippy::single_match)]
+
 #[cfg(not(target_arch = "wasm32"))]
 fn main() {
     use std::{collections::HashMap, sync::mpsc, thread, time::Duration};

examples/multiwindow.rs

@@ -1,3 +1,5 @@
+#![allow(clippy::single_match)]
+
 use std::collections::HashMap;
 
 use simple_logger::SimpleLogger;

examples/request_redraw.rs

@@ -1,3 +1,5 @@
+#![allow(clippy::single_match)]
+
 use simple_logger::SimpleLogger;
 use winit::{
     event::{ElementState, Event, WindowEvent},

examples/request_redraw_threaded.rs

@@ -1,3 +1,5 @@
+#![allow(clippy::single_match)]
+
 #[cfg(not(target_arch = "wasm32"))]
 fn main() {
     use std::{thread, time};
@@ -28,10 +30,10 @@ fn main() {
         control_flow.set_wait();
 
         match event {
-            Event::WindowEvent { event, .. } => match event {
-                WindowEvent::CloseRequested => control_flow.set_exit(),
-                _ => (),
-            },
+            Event::WindowEvent {
+                event: WindowEvent::CloseRequested,
+                ..
+            } => control_flow.set_exit(),
             Event::RedrawRequested(_) => {
                 println!("\nredrawing!\n");
             }

examples/resizable.rs

@@ -1,3 +1,5 @@
+#![allow(clippy::single_match)]
+
 use simple_logger::SimpleLogger;
 use winit::{
     dpi::LogicalSize,

examples/timer.rs

@@ -1,3 +1,5 @@
+#![allow(clippy::single_match)]
+
 use instant::Instant;
 use std::time::Duration;
 

examples/transparent.rs

@@ -1,3 +1,5 @@
+#![allow(clippy::single_match)]
+
 use simple_logger::SimpleLogger;
 use winit::{
     event::{Event, WindowEvent},

examples/video_modes.rs

@@ -1,3 +1,5 @@
+#![allow(clippy::single_match)]
+
 use simple_logger::SimpleLogger;
 use winit::event_loop::EventLoop;
 

examples/web.rs

@@ -1,3 +1,5 @@
+#![allow(clippy::single_match)]
+
 use winit::{
     event::{Event, WindowEvent},
     event_loop::EventLoop,
@@ -43,6 +45,7 @@ mod wasm {
     pub fn run() {
         console_log::init_with_level(log::Level::Debug).expect("error initializing logger");
 
+        #[allow(clippy::main_recursion)]
         super::main();
     }
 

examples/window.rs

@@ -1,3 +1,5 @@
+#![allow(clippy::single_match)]
+
 use simple_logger::SimpleLogger;
 use winit::{
     event::{Event, WindowEvent},

examples/window_debug.rs

@@ -1,3 +1,5 @@
+#![allow(clippy::single_match)]
+
 // This example is used by developers to test various window functions.
 
 use simple_logger::SimpleLogger;
@@ -58,61 +60,63 @@ fn main() {
                 _ => (),
             },
             Event::WindowEvent {
-                event: WindowEvent::KeyboardInput { input, .. },
+                event:
+                    WindowEvent::KeyboardInput {
+                        input:
+                            KeyboardInput {
+                                virtual_keycode: Some(key),
+                                state: ElementState::Pressed,
+                                ..
+                            },
+                        ..
+                    },
                 ..
-            } => match input {
-                KeyboardInput {
-                    virtual_keycode: Some(key),
-                    state: ElementState::Pressed,
-                    ..
-                } => match key {
-                    VirtualKeyCode::E => {
-                        fn area(size: PhysicalSize<u32>) -> u32 {
-                            size.width * size.height
-                        }
-
-                        let monitor = window.current_monitor().unwrap();
-                        if let Some(mode) = monitor
-                            .video_modes()
-                            .max_by(|a, b| area(a.size()).cmp(&area(b.size())))
-                        {
-                            window.set_fullscreen(Some(Fullscreen::Exclusive(mode)));
-                        } else {
-                            eprintln!("no video modes available");
-                        }
-                    }
-                    VirtualKeyCode::F => {
-                        if window.fullscreen().is_some() {
-                            window.set_fullscreen(None);
-                        } else {
-                            let monitor = window.current_monitor();
-                            window.set_fullscreen(Some(Fullscreen::Borderless(monitor)));
-                        }
-                    }
-                    VirtualKeyCode::P => {
-                        if window.fullscreen().is_some() {
-                            window.set_fullscreen(None);
-                        } else {
-                            window.set_fullscreen(Some(Fullscreen::Borderless(None)));
-                        }
-                    }
-                    VirtualKeyCode::M => {
-                        minimized = !minimized;
-                        window.set_minimized(minimized);
+            } => match key {
+                VirtualKeyCode::E => {
+                    fn area(size: PhysicalSize<u32>) -> u32 {
+                        size.width * size.height
                     }
-                    VirtualKeyCode::Q => {
-                        control_flow.set_exit();
+
+                    let monitor = window.current_monitor().unwrap();
+                    if let Some(mode) = monitor
+                        .video_modes()
+                        .max_by(|a, b| area(a.size()).cmp(&area(b.size())))
+                    {
+                        window.set_fullscreen(Some(Fullscreen::Exclusive(mode)));
+                    } else {
+                        eprintln!("no video modes available");
                     }
-                    VirtualKeyCode::V => {
-                        visible = !visible;
-                        window.set_visible(visible);
+                }
+                VirtualKeyCode::F => {
+                    if window.fullscreen().is_some() {
+                        window.set_fullscreen(None);
+                    } else {
+                        let monitor = window.current_monitor();
+                        window.set_fullscreen(Some(Fullscreen::Borderless(monitor)));
                     }
-                    VirtualKeyCode::X => {
-                        let is_maximized = window.is_maximized();
-                        window.set_maximized(!is_maximized);
+                }
+                VirtualKeyCode::P => {
+                    if window.fullscreen().is_some() {
+                        window.set_fullscreen(None);
+                    } else {
+                        window.set_fullscreen(Some(Fullscreen::Borderless(None)));
                     }
-                    _ => (),
-                },
+                }
+                VirtualKeyCode::M => {
+                    minimized = !minimized;
+                    window.set_minimized(minimized);
+                }
+                VirtualKeyCode::Q => {
+                    control_flow.set_exit();
+                }
+                VirtualKeyCode::V => {
+                    visible = !visible;
+                    window.set_visible(visible);
+                }
+                VirtualKeyCode::X => {
+                    let is_maximized = window.is_maximized();
+                    window.set_maximized(!is_maximized);
+                }
                 _ => (),
             },
             Event::WindowEvent {

examples/window_icon.rs

@@ -1,4 +1,5 @@
-extern crate image;
+#![allow(clippy::single_match)]
+
 use std::path::Path;
 
 use simple_logger::SimpleLogger;

examples/window_run_return.rs

@@ -1,3 +1,5 @@
+#![allow(clippy::single_match)]
+
 // Limit this example to only compatible platforms.
 #[cfg(any(
     target_os = "windows",

src/event_loop.rs

@@ -94,6 +94,8 @@ impl<T> EventLoopBuilder<T> {
     ///   will fall back on X11. If this variable is set with any other value, winit will panic.
     #[inline]
     pub fn build(&mut self) -> EventLoop<T> {
+        // Certain platforms accept a mutable reference in their API.
+        #[allow(clippy::unnecessary_mut_passed)]
         EventLoop {
             event_loop: platform_impl::EventLoop::new(&mut self.platform_specific),
             _marker: PhantomData,
@@ -221,6 +223,12 @@ impl EventLoop<()> {
     }
 }
 
+impl Default for EventLoop<()> {
+    fn default() -> Self {
+        Self::new()
+    }
+}
+
 impl<T> EventLoop<T> {
     #[deprecated = "Use `EventLoopBuilder::<T>::with_user_event().build()` instead."]
     pub fn with_user_event() -> EventLoop<T> {

src/lib.rs

@@ -132,6 +132,9 @@
 
 #![deny(rust_2018_idioms)]
 #![deny(rustdoc::broken_intra_doc_links)]
+#![deny(clippy::all)]
+#![cfg_attr(feature = "cargo-clippy", deny(warnings))]
+#![allow(clippy::missing_safety_doc)]
 
 #[allow(unused_imports)]
 #[macro_use]

src/platform_impl/android/mod.rs

@@ -240,7 +240,7 @@ pub struct EventLoop<T: 'static> {
     running: bool,
 }
 
-#[derive(Default, Debug, Copy, Clone, PartialEq, Hash)]
+#[derive(Default, Debug, Copy, Clone, PartialEq, Eq, Hash)]
 pub(crate) struct PlatformSpecificEventLoopAttributes {}
 
 macro_rules! call_event_handler {
@@ -846,18 +846,16 @@ impl MonitorHandle {
 
     pub fn video_modes(&self) -> impl Iterator<Item = monitor::VideoMode> {
         let size = self.size().into();
-        let mut v = Vec::new();
         // FIXME this is not the real refresh rate
-        // (it is guarunteed to support 32 bit color though)
-        v.push(monitor::VideoMode {
+        // (it is guaranteed to support 32 bit color though)
+        std::iter::once(monitor::VideoMode {
             video_mode: VideoMode {
                 size,
                 bit_depth: 32,
                 refresh_rate: 60,
                 monitor: self.clone(),
             },
-        });
-        v.into_iter()
+        })
     }
 }