fix clippy warnings (#1510)

* fix clippy warnings

* update changelog

Author: antonilol

changelog.md

@@ -3,6 +3,8 @@ when upgrading from a version of rust-sdl2 to another.
 
 ### v0.39.0
 
+[PR #1510](https://github.com/Rust-SDL2/rust-sdl2/pull/1510) Fix clippy warnings.
+
 [PR #1509](https://github.com/Rust-SDL2/rust-sdl2/pull/1509) **BREAKING CHANGE** Add Send + 'static bounds for EventWatchCallback and 'static bound to AudioCallback to avoid soundness hole.
 
 [PR #1506](https://github.com/Rust-SDL2/rust-sdl2/pull/1506) **BREAKING CHANGE** Update crates.io dependencies, update bundled SDL2 to 2.32.10, add whitelist to bindgen to only emit SDL related items, and specifically no platform (or compiler, etc) specific items. Implement the same set of useful derived traits on bitflags types.

examples/resource-manager.rs

@@ -127,7 +127,7 @@ where
 // TextureCreator knows how to load Textures
 impl<'l, T> ResourceLoader<'l, Texture<'l>> for TextureCreator<T> {
     type Args = str;
-    fn load(&'l self, path: &str) -> Result<Texture, String> {
+    fn load(&'l self, path: &str) -> Result<Texture<'l>, String> {
         println!("LOADED A TEXTURE");
         self.load_texture(path)
     }

src/sdl2/audio.rs

@@ -1025,7 +1025,7 @@ impl<CB: AudioCallback> AudioDevice<CB> {
     /// called.
     /// Use this method to read and mutate callback data.
     #[doc(alias = "SDL_LockAudioDevice")]
-    pub fn lock(&mut self) -> AudioDeviceLockGuard<CB> {
+    pub fn lock(&mut self) -> AudioDeviceLockGuard<'_, CB> {
         unsafe { sys::SDL_LockAudioDevice(self.device_id.id()) };
         AudioDeviceLockGuard {
             device: self,

src/sdl2/event.rs

@@ -2770,7 +2770,7 @@ impl crate::EventPump {
     ///     }
     /// }
     /// ```
-    pub fn poll_iter(&mut self) -> EventPollIterator {
+    pub fn poll_iter(&mut self) -> EventPollIterator<'_> {
         EventPollIterator {
             _marker: PhantomData,
         }
@@ -2797,7 +2797,7 @@ impl crate::EventPump {
     /// Returns a waiting iterator that calls `wait_event()`.
     ///
     /// Note: The iterator will never terminate.
-    pub fn wait_iter(&mut self) -> EventWaitIterator {
+    pub fn wait_iter(&mut self) -> EventWaitIterator<'_> {
         EventWaitIterator {
             _marker: PhantomData,
         }
@@ -2807,15 +2807,15 @@ impl crate::EventPump {
     ///
     /// Note: The iterator will never terminate, unless waiting for an event
     /// exceeds the specified timeout.
-    pub fn wait_timeout_iter(&mut self, timeout: u32) -> EventWaitTimeoutIterator {
+    pub fn wait_timeout_iter(&mut self, timeout: u32) -> EventWaitTimeoutIterator<'_> {
         EventWaitTimeoutIterator {
             _marker: PhantomData,
             timeout,
         }
     }
 
     #[inline]
-    pub fn keyboard_state(&self) -> crate::keyboard::KeyboardState {
+    pub fn keyboard_state(&self) -> crate::keyboard::KeyboardState<'_> {
         crate::keyboard::KeyboardState::new(self)
     }
 

src/sdl2/gfx/rotozoom.rs

@@ -9,25 +9,25 @@ use sys::gfx::rotozoom;
 /// `RotozoomSurface` for work with rust-sdl2 Surface type
 pub trait RotozoomSurface {
     /// Rotates and zooms a surface and optional anti-aliasing.
-    fn rotozoom(&self, angle: f64, zoom: f64, smooth: bool) -> Result<Surface, String>;
+    fn rotozoom(&self, angle: f64, zoom: f64, smooth: bool) -> Result<Surface<'_>, String>;
     /// Rotates and zooms a surface with different horizontal and vertical scaling factors and optional anti-aliasing.
     fn rotozoom_xy(
         &self,
         angle: f64,
         zoomx: f64,
         zoomy: f64,
         smooth: bool,
-    ) -> Result<Surface, String>;
+    ) -> Result<Surface<'_>, String>;
     /// Zoom a surface by independent horizontal and vertical factors with optional smoothing.
-    fn zoom(&self, zoomx: f64, zoomy: f64, smooth: bool) -> Result<Surface, String>;
+    fn zoom(&self, zoomx: f64, zoomy: f64, smooth: bool) -> Result<Surface<'_>, String>;
     /// Shrink a surface by an integer ratio using averaging.
-    fn shrink(&self, factorx: i32, factory: i32) -> Result<Surface, String>;
+    fn shrink(&self, factorx: i32, factory: i32) -> Result<Surface<'_>, String>;
     /// Rotates a 8/16/24/32 bit surface in increments of 90 degrees.
-    fn rotate_90deg(&self, turns: i32) -> Result<Surface, String>;
+    fn rotate_90deg(&self, turns: i32) -> Result<Surface<'_>, String>;
 }
 
 impl<'a> RotozoomSurface for Surface<'a> {
-    fn rotozoom(&self, angle: f64, zoom: f64, smooth: bool) -> Result<Surface, String> {
+    fn rotozoom(&self, angle: f64, zoom: f64, smooth: bool) -> Result<Surface<'_>, String> {
         let raw = unsafe { rotozoom::rotozoomSurface(self.raw(), angle, zoom, smooth as c_int) };
         if (raw as *mut ()).is_null() {
             Err(get_error())
@@ -41,7 +41,7 @@ impl<'a> RotozoomSurface for Surface<'a> {
         zoomx: f64,
         zoomy: f64,
         smooth: bool,
-    ) -> Result<Surface, String> {
+    ) -> Result<Surface<'_>, String> {
         let raw = unsafe {
             rotozoom::rotozoomSurfaceXY(self.raw(), angle, zoomx, zoomy, smooth as c_int)
         };
@@ -51,15 +51,15 @@ impl<'a> RotozoomSurface for Surface<'a> {
             unsafe { Ok(Surface::from_ll(raw)) }
         }
     }
-    fn zoom(&self, zoomx: f64, zoomy: f64, smooth: bool) -> Result<Surface, String> {
+    fn zoom(&self, zoomx: f64, zoomy: f64, smooth: bool) -> Result<Surface<'_>, String> {
         let raw = unsafe { rotozoom::zoomSurface(self.raw(), zoomx, zoomy, smooth as c_int) };
         if (raw as *mut ()).is_null() {
             Err(get_error())
         } else {
             unsafe { Ok(Surface::from_ll(raw)) }
         }
     }
-    fn shrink(&self, factorx: i32, factory: i32) -> Result<Surface, String> {
+    fn shrink(&self, factorx: i32, factory: i32) -> Result<Surface<'_>, String> {
         let raw =
             unsafe { rotozoom::shrinkSurface(self.raw(), factorx as c_int, factory as c_int) };
         if (raw as *mut ()).is_null() {
@@ -68,7 +68,7 @@ impl<'a> RotozoomSurface for Surface<'a> {
             unsafe { Ok(Surface::from_ll(raw)) }
         }
     }
-    fn rotate_90deg(&self, turns: i32) -> Result<Surface, String> {
+    fn rotate_90deg(&self, turns: i32) -> Result<Surface<'_>, String> {
         let raw = unsafe { rotozoom::rotateSurface90Degrees(self.raw(), turns as c_int) };
         if (raw as *mut ()).is_null() {
             Err(get_error())

src/sdl2/hint.rs

@@ -25,7 +25,7 @@ pub enum Hint {
 /// ```
 ///
 /// * `value`: `true` to enable minimizing of the Window if it loses key focus when in fullscreen mode,
-///            `false` to disable this feature.
+///   `false` to disable this feature.
 pub fn set_video_minimize_on_focus_loss(value: bool) -> bool {
     set(VIDEO_MINIMIZE_ON_FOCUS_LOSS, if value { "1" } else { "0" })
 }
@@ -41,10 +41,10 @@ pub fn set_video_minimize_on_focus_loss(value: bool) -> bool {
 /// ```
 ///
 /// * `value`: `true` to enable minimizing of the Window if it loses key focus when in fullscreen mode,
-///            `false` to disable this feature.
+///   `false` to disable this feature.
 /// * `priority`: The priority controls the behavior when setting a hint that already has a value.
-///               Hints will replace existing hints of their priority and lower.
-///               Environment variables are considered to have override priority.
+///   Hints will replace existing hints of their priority and lower.
+///   Environment variables are considered to have override priority.
 pub fn set_video_minimize_on_focus_loss_with_priority(value: bool, priority: &Hint) -> bool {
     set_with_priority(
         VIDEO_MINIMIZE_ON_FOCUS_LOSS,

src/sdl2/image/mod.rs

@@ -134,12 +134,12 @@ impl<'a> SaveSurface for Surface<'a> {
 
 /// Method extensions for creating Textures from a `TextureCreator`
 pub trait LoadTexture {
-    fn load_texture<P: AsRef<Path>>(&self, filename: P) -> Result<Texture, String>;
-    fn load_texture_bytes(&self, buf: &[u8]) -> Result<Texture, String>;
+    fn load_texture<P: AsRef<Path>>(&self, filename: P) -> Result<Texture<'_>, String>;
+    fn load_texture_bytes(&self, buf: &[u8]) -> Result<Texture<'_>, String>;
 }
 
 impl<T> LoadTexture for TextureCreator<T> {
-    fn load_texture<P: AsRef<Path>>(&self, filename: P) -> Result<Texture, String> {
+    fn load_texture<P: AsRef<Path>>(&self, filename: P) -> Result<Texture<'_>, String> {
         //! Loads an SDL Texture from a file
         unsafe {
             let c_filename = CString::new(filename.as_ref().to_str().unwrap()).unwrap();
@@ -153,7 +153,7 @@ impl<T> LoadTexture for TextureCreator<T> {
     }
 
     #[doc(alias = "IMG_LoadTexture")]
-    fn load_texture_bytes(&self, buf: &[u8]) -> Result<Texture, String> {
+    fn load_texture_bytes(&self, buf: &[u8]) -> Result<Texture<'_>, String> {
         //! Loads an SDL Texture from a buffer that the format must be something supported by SDL2_image (png, jpeg, ect, but NOT RGBA8888 bytes for instance)
         unsafe {
             let buf = sdl2_sys::SDL_RWFromMem(buf.as_ptr() as *mut libc::c_void, buf.len() as i32);

src/sdl2/keyboard/mod.rs

@@ -72,7 +72,7 @@ impl<'a> KeyboardState<'a> {
     }
 
     /// Returns an iterator all scancodes with a boolean indicating if the scancode is pressed.
-    pub fn scancodes(&self) -> ScancodeIterator {
+    pub fn scancodes(&self) -> ScancodeIterator<'_> {
         ScancodeIterator {
             index: 0,
             keyboard_state: self.keyboard_state,
@@ -102,7 +102,7 @@ impl<'a> KeyboardState<'a> {
     ///     // sugar for: new.difference(old).collect()
     /// }
     /// ```
-    pub fn pressed_scancodes(&self) -> PressedScancodeIterator {
+    pub fn pressed_scancodes(&self) -> PressedScancodeIterator<'_> {
         self.scancodes().into_pressed_scancode_iter()
     }
 }

src/sdl2/log.rs

@@ -45,7 +45,7 @@ impl Category {
     }
 
     fn into_ll(value: Category) -> u32 {
-        return match value {
+        match value {
             Category::Application => sys::SDL_LogCategory::SDL_LOG_CATEGORY_APPLICATION as u32,
             Category::Error => sys::SDL_LogCategory::SDL_LOG_CATEGORY_ERROR as u32,
             Category::Assert => sys::SDL_LogCategory::SDL_LOG_CATEGORY_ASSERT as u32,
@@ -57,7 +57,7 @@ impl Category {
             Category::Test => sys::SDL_LogCategory::SDL_LOG_CATEGORY_TEST as u32,
             Category::Custom => sys::SDL_LogCategory::SDL_LOG_CATEGORY_CUSTOM as u32,
             Category::Unknown => sys::SDL_LogCategory::SDL_LOG_CATEGORY_APPLICATION as u32,
-        };
+        }
     }
 }
 
@@ -80,7 +80,7 @@ impl Priority {
             SDL_LOG_PRIORITY_INFO => Priority::Info,
             SDL_LOG_PRIORITY_WARN => Priority::Warn,
             SDL_LOG_PRIORITY_ERROR => Priority::Error,
-            SDL_LOG_PRIORITY_CRITICAL | _ => Priority::Critical,
+            _ /* | SDL_LOG_PRIORITY_CRITICAL */ => Priority::Critical,
         }
     }
 }

src/sdl2/mixer/mod.rs

@@ -163,10 +163,10 @@ pub fn init(flags: InitFlag) -> Result<Sdl2MixerContext, String> {
 /// or require more fine-grained control over the device configuration, use [`open_audio_device`].
 ///
 /// * `chunksize`: It is recommended to choose values between 256 and 1024, depending on whether
-///                you prefer latency or compatibility. Small values reduce latency but may not
-///                work very well on older systems. For instance, a chunk size of 256 will give
-///                you a latency of 6ms, while a chunk size of 1024 will give you a latency of 23ms
-///                for a frequency of 44100kHz.
+///   you prefer latency or compatibility. Small values reduce latency but may not
+///   work very well on older systems. For instance, a chunk size of 256 will give
+///   you a latency of 6ms, while a chunk size of 1024 will give you a latency of 23ms
+///   for a frequency of 44100kHz.
 pub fn open_audio(
     frequency: i32,
     format: AudioFormat,
@@ -207,8 +207,8 @@ pub fn open_audio(
 /// * `format`: Audio format ([`AudioFormat`]).
 /// * `channels`: Number of channels (1 is mono, 2 is stereo, etc).
 /// * `chunksize`: Audio buffer size in sample FRAMES (total samples divided by channel count).
-///                The lower the number, the lower the latency, but you risk dropouts if it gets
-///                too low.
+///   The lower the number, the lower the latency, but you risk dropouts if it gets
+///   too low.
 /// * `device`: The device name to open, or [`None`] to choose a reasonable default.
 /// * `allowed_changes`: Allow change flags ([`AllowChangeFlag`]).
 ///
@@ -545,7 +545,7 @@ impl Channel {
         match ret {
             mixer::Mix_Fading_MIX_FADING_OUT => Fading::FadingOut,
             mixer::Mix_Fading_MIX_FADING_IN => Fading::FadingIn,
-            mixer::Mix_Fading_MIX_NO_FADING | _ => Fading::NoFading,
+            _ /* | mixer::Mix_Fading_MIX_NO_FADING */ => Fading::NoFading,
         }
     }
 
@@ -872,7 +872,7 @@ impl<'a> Music<'a> {
             mixer::Mix_MusicType_MUS_MP3_MAD_UNUSED => MusicType::MusicMp3Mad,
             mixer::Mix_MusicType_MUS_FLAC => MusicType::MusicFlac,
             mixer::Mix_MusicType_MUS_MODPLUG_UNUSED => MusicType::MusicModPlug,
-            mixer::Mix_MusicType_MUS_NONE | _ => MusicType::MusicNone,
+            _ /* | mixer::Mix_MusicType_MUS_NONE */ => MusicType::MusicNone,
         }
     }
 
@@ -1029,7 +1029,7 @@ impl<'a> Music<'a> {
         match ret {
             mixer::Mix_Fading_MIX_FADING_OUT => Fading::FadingOut,
             mixer::Mix_Fading_MIX_FADING_IN => Fading::FadingIn,
-            mixer::Mix_Fading_MIX_NO_FADING | _ => Fading::NoFading,
+            _ /* | mixer::Mix_Fading_MIX_NO_FADING */ => Fading::NoFading,
         }
     }
 }