Require clippy lints to pass

.github/workflows/ci.yml

@@ -23,11 +23,11 @@ jobs:
       - uses: actions/checkout@v3
       - uses: dtolnay/[email protected]
       - name: Minimal check
-        run: cargo check -v -p palette --no-default-features --features std
+        run: cargo clippy -v -p palette --no-default-features --features std
       - name: find-crate check
-        run: cargo check -v -p palette --no-default-features --features "std find-crate"
+        run: cargo clippy -v -p palette --no-default-features --features "std find-crate"
       - name: Default check
-        run: cargo check -v --workspace --exclude no_std_test
+        run: cargo clippy -v --workspace --exclude no_std_test
       - name: Test all features
         run: cargo test -v -p palette --all-features
       - name: Test each feature
@@ -48,7 +48,7 @@ jobs:
         with:
           toolchain: ${{ matrix.toolchain }}
       - name: Check all features
-        run: cargo check -v -p palette --all-features
+        run: cargo clippy -v -p palette --all-features
   no_std:
     name: "Test #[no_std]"
     runs-on: ubuntu-latest

.vscode/settings.json

@@ -7,5 +7,6 @@
     ],
     "rust-analyzer.imports.granularity.enforce": true,
     "rust-analyzer.imports.granularity.group": "crate",
-    "rust-analyzer.imports.group.enable": true
-}
+    "rust-analyzer.imports.group.enable": true,
+    "rust-analyzer.check.command": "clippy"
+}

palette/Cargo.toml

@@ -25,6 +25,7 @@ edition = "2018"
 resolver = "2"
 categories = ["graphics", "multimedia::images", "no-std"]
 build = "build/main.rs"
+rust-version = "1.60.0"
 
 [features]
 default = ["named_from_str", "std", "approx"]

palette/benches/matrix.rs

@@ -36,7 +36,7 @@ fn matrix(c: &mut Criterion) {
         b.iter(|| matrix_inverse(*inverse))
     });
     group.bench_function("rgb_to_xyz_matrix", |b| {
-        b.iter(|| rgb_to_xyz_matrix::<encoding::Srgb, f32>())
+        b.iter(rgb_to_xyz_matrix::<encoding::Srgb, f32>)
     });
 }
 

palette/examples/blend.rs

@@ -45,7 +45,7 @@ fn main() {
                 &mut image,
                 x,
                 y,
-                0 * ALPHA_STEPS + alpha_step,
+                alpha_step,
                 tile_width,
                 tile_height,
                 foreground,
@@ -56,7 +56,7 @@ fn main() {
                 &mut image,
                 x,
                 y,
-                1 * ALPHA_STEPS + alpha_step,
+                ALPHA_STEPS + alpha_step,
                 tile_width,
                 tile_height,
                 Xyza::from_color(foreground),
@@ -72,6 +72,7 @@ fn main() {
     }
 }
 
+#[allow(clippy::too_many_arguments)]
 fn draw_composed_pixels<C>(
     image: &mut image::RgbaImage,
     x: u32,
@@ -106,11 +107,9 @@ fn draw_composed_pixels<C>(
     }
 }
 
-fn compose<C>(
-    fg: Alpha<C, f32>,
-    bg: Alpha<C, f32>,
-    function: fn(Alpha<C, f32>, Alpha<C, f32>) -> Alpha<C, f32>,
-) -> image::Rgba<u8>
+type ComposeFn<C> = fn(Alpha<C, f32>, Alpha<C, f32>) -> Alpha<C, f32>;
+
+fn compose<C>(fg: Alpha<C, f32>, bg: Alpha<C, f32>, function: ComposeFn<C>) -> image::Rgba<u8>
 where
     Alpha<C, f32>: Blend + IntoColor<LinSrgba>,
 {

palette/examples/color_scheme.rs

@@ -155,9 +155,9 @@ fn blit_shades(color: LinSrgb<f32>, mut canvas: SubImage<&mut RgbImage>) {
     let primary = Srgb::from_linear(color).into();
 
     //Generate one lighter and two darker versions of the color
-    let light = Srgb::from_linear(color.lighten(0.1).into()).into();
-    let dark1 = Srgb::from_linear(color.darken(0.1).into()).into();
-    let dark2 = Srgb::from_linear(color.darken(0.2).into()).into();
+    let light = Srgb::from_linear(color.lighten(0.1)).into();
+    let dark1 = Srgb::from_linear(color.darken(0.1)).into();
+    let dark2 = Srgb::from_linear(color.darken(0.2)).into();
 
     for x in 0..width {
         for y in 0..height {

palette/examples/compose.rs

@@ -56,7 +56,7 @@ fn main() {
                 &mut image,
                 x,
                 y,
-                0 * ALPHA_STEPS + alpha_step,
+                alpha_step,
                 tile_width,
                 tile_height,
                 foreground.into(),
@@ -67,7 +67,7 @@ fn main() {
                 &mut image,
                 x,
                 y,
-                1 * ALPHA_STEPS + alpha_step,
+                ALPHA_STEPS + alpha_step,
                 tile_width,
                 tile_height,
                 Xyza::from_color(foreground).into(),
@@ -127,6 +127,7 @@ fn main() {
     }
 }
 
+#[allow(clippy::too_many_arguments)]
 fn draw_composed_pixels<C>(
     image: &mut image::RgbaImage,
     x: u32,

palette/examples/readme_examples.rs

@@ -177,7 +177,7 @@ fn display_colors(filename: &str, displays: &[DisplayType]) {
 
     let mut image = RgbImage::new(WIDTH, displays.len() as u32 * row_height);
 
-    for (i, display) in displays.into_iter().enumerate() {
+    for (i, display) in displays.iter().enumerate() {
         let image = image.sub_image(0, i as u32 * row_height, WIDTH, row_height);
         match *display {
             DisplayType::Discrete(colors) => {

palette/src/alpha.rs

@@ -10,6 +10,7 @@ pub use self::alpha::*;
 #[doc(no_inline)]
 pub use crate::blend::PreAlpha; // Cross-link for visibility.
 
+#[allow(clippy::module_inception)]
 mod alpha;
 
 /// A trait for color types that can have or be given transparency (alpha channel).

palette/src/blend.rs

@@ -50,6 +50,7 @@ pub use self::{
     pre_alpha::PreAlpha,
 };
 
+#[allow(clippy::module_inception)]
 mod blend;
 mod blend_with;
 mod compose;

palette/src/cast/from_into_components_traits.rs

@@ -581,7 +581,7 @@ where
     }
 }
 
-impl<'a, T, C> TryComponentsInto<C> for T
+impl<T, C> TryComponentsInto<C> for T
 where
     C: TryFromComponents<T>,
 {

palette/src/color_difference.rs

@@ -463,11 +463,12 @@ mod test {
         assert!(c1.has_enhanced_contrast_text(white));
         assert!(c1.has_enhanced_contrast_large_text(white));
         assert!(c1.has_min_contrast_graphics(white));
-        assert!(c1.has_min_contrast_text(black) == false);
-        assert!(c1.has_min_contrast_large_text(black) == false);
-        assert!(c1.has_enhanced_contrast_text(black) == false);
-        assert!(c1.has_enhanced_contrast_large_text(black) == false);
-        assert!(c1.has_min_contrast_graphics(black) == false);
+
+        assert!(!c1.has_min_contrast_text(black));
+        assert!(!c1.has_min_contrast_large_text(black));
+        assert!(!c1.has_enhanced_contrast_text(black));
+        assert!(!c1.has_enhanced_contrast_large_text(black));
+        assert!(!c1.has_min_contrast_graphics(black));
 
         let c1 = Srgb::from_str("#066").unwrap().into_format();
 

palette/src/convert.rs

@@ -196,19 +196,17 @@
 //!     }
 //! }
 //!
-//! fn main() {
-//!     // Start with an Xyz100 color.
-//!     let xyz = Xyz100 {
-//!         x: 59,
-//!         y: 75,
-//!         z: 42,
-//!     };
+//! // Start with an Xyz100 color.
+//! let xyz = Xyz100 {
+//!     x: 59,
+//!     y: 75,
+//!     z: 42,
+//! };
 //!
-//!     // Convert the color to sRGB.
-//!     let rgb: Srgb = xyz.into_color();
+//! // Convert the color to sRGB.
+//! let rgb: Srgb = xyz.into_color();
 //!
-//!     assert_eq!(rgb.into_format(), Srgb::new(196u8, 238, 154));
-//! }
+//! assert_eq!(rgb.into_format(), Srgb::new(196u8, 238, 154));
 //! ```
 //!
 //! With generic components:

palette/src/convert/from_into_color_mut.rs

@@ -200,6 +200,7 @@ where
     ///
     /// This reuses the memory space, and the returned scope guard will restore
     /// the converted colors to their original type when it's dropped.
+    #[allow(clippy::wrong_self_convention)]
     #[must_use]
     fn into_color_mut(&mut self) -> FromColorMutGuard<T, Self>;
 }
@@ -308,7 +309,7 @@ where
             .and_then(|mut guard| guard.current.take());
 
         if let Some(restored) = restored {
-            return restored;
+            restored
         } else {
             unreachable!()
         }

palette/src/convert/from_into_color_unclamped_mut.rs

@@ -201,6 +201,7 @@ where
     ///
     /// This reuses the memory space, and the returned scope guard will restore
     /// the converted colors to their original type when it's dropped.
+    #[allow(clippy::wrong_self_convention)]
     #[must_use]
     fn into_color_unclamped_mut(&mut self) -> FromColorUnclampedMutGuard<T, Self>;
 }

palette/src/convert/try_from_into_color.rs

@@ -64,7 +64,6 @@ pub trait TryFromColor<T>: Sized {
     ///     }
     /// };
     /// ```
-    #[must_use]
     fn try_from_color(t: T) -> Result<Self, OutOfBounds<Self>>;
 }
 
@@ -105,7 +104,6 @@ pub trait TryIntoColor<T>: Sized {
     ///     }
     /// };
     /// ```
-    #[must_use]
     fn try_into_color(self) -> Result<T, OutOfBounds<T>>;
 }
 

palette/src/hues.rs

@@ -287,31 +287,38 @@ macro_rules! make_hues {
             }
         }
 
-        impl Into<f64> for $name<f64> {
+        impl From<$name<f64>> for f64 {
             #[inline]
-            fn into(self) -> f64 {
-                self.0.normalize_signed_angle()
+            fn from(hue: $name<f64>) -> f64 {
+                hue.0.normalize_signed_angle()
             }
         }
 
-        impl Into<f32> for $name<f32> {
+        impl From<$name<f32>> for f64 {
             #[inline]
-            fn into(self) -> f32 {
-                self.0.normalize_signed_angle()
+            fn from(hue: $name<f32>) -> f64 {
+                hue.0.normalize_signed_angle() as f64
             }
         }
 
-        impl Into<f32> for $name<f64> {
+        impl From<$name<f32>> for f32 {
             #[inline]
-            fn into(self) -> f32 {
-                self.0.normalize_signed_angle() as f32
+            fn from(hue: $name<f32>) -> f32 {
+                hue.0.normalize_signed_angle()
             }
         }
 
-        impl Into<u8> for $name<u8> {
+        impl From<$name<f64>> for f32 {
             #[inline]
-            fn into(self) -> u8 {
-                self.0
+            fn from(hue: $name<f64>) -> f32 {
+                hue.0.normalize_signed_angle() as f32
+            }
+        }
+
+        impl From<$name<u8>> for u8 {
+            #[inline]
+            fn from(hue: $name<u8>) -> u8 {
+                hue.0
             }
         }
 
@@ -893,7 +900,7 @@ mod test {
             assert!(degs > -180.0 && degs <= 180.0);
 
             let pos_degs = hue.into_positive_degrees();
-            assert!(pos_degs >= 0.0 && pos_degs < 360.0);
+            assert!((0.0..360.0).contains(&pos_degs));
 
             assert_relative_eq!(RgbHue::from(degs), RgbHue::from(pos_degs));
         }

palette/src/hwb.rs

@@ -660,8 +660,8 @@ where
 
     #[rustfmt::skip]
     fn ulps_eq(&self, other: &Self, epsilon: Self::Epsilon, max_ulps: u32) -> bool {
-        let equal_shade = self.whiteness.ulps_eq(&other.whiteness, epsilon.clone(), max_ulps.clone())
-            && self.blackness.ulps_eq(&other.blackness, epsilon.clone(), max_ulps.clone());
+        let equal_shade = self.whiteness.ulps_eq(&other.whiteness, epsilon.clone(), max_ulps)
+            && self.blackness.ulps_eq(&other.blackness, epsilon.clone(), max_ulps);
 
         // The hue doesn't matter that much when the color is gray, and may fluctuate
         // due to precision errors. This is a blunt tool, but works for now.

palette/src/lch.rs

@@ -554,11 +554,11 @@ mod test {
 
     #[test]
     fn check_min_max_components() {
-        assert_relative_eq!(Lch::<D65, f32>::min_l(), 0.0);
-        assert_relative_eq!(Lch::<D65, f32>::max_l(), 100.0);
-        assert_relative_eq!(Lch::<D65, f32>::min_chroma(), 0.0);
-        assert_relative_eq!(Lch::<D65, f32>::max_chroma(), 128.0);
-        assert_relative_eq!(Lch::<D65, f32>::max_extended_chroma(), 181.01933598375618);
+        assert_relative_eq!(Lch::<D65, f64>::min_l(), 0.0);
+        assert_relative_eq!(Lch::<D65, f64>::max_l(), 100.0);
+        assert_relative_eq!(Lch::<D65, f64>::min_chroma(), 0.0);
+        assert_relative_eq!(Lch::<D65, f64>::max_chroma(), 128.0);
+        assert_relative_eq!(Lch::<D65, f64>::max_extended_chroma(), 181.01933598375618);
     }
 
     struct_of_arrays_tests!(

palette/src/luma.rs

@@ -1,6 +1,7 @@
 //! Types for luma and luminance (grayscale) values.
 
 pub mod channels;
+#[allow(clippy::module_inception)]
 mod luma;
 
 use crate::encoding::{Gamma, Linear, Srgb};

palette/src/okhsv.rs

@@ -388,19 +388,19 @@ mod tests {
         // 1 iteration : 264.0520206380550121, 0.9999910912349018, 0.9999999646150918
         // 2 iterations: 264.0520206380550121, 0.9999999869716002, 0.9999999646150844
         // 3 iterations: 264.0520206380550121, 0.9999999869716024, 0.9999999646150842
+        #[allow(clippy::excessive_precision)]
+        let expected_hue = OklabHue::new(264.0520206380550121);
+        let expected_saturation = 0.9999910912349018;
+        let expected_value = 0.9999999646150918;
 
         // compare to the reference implementation values
-        assert_abs_diff_eq!(
-            okhsv_blue_64.hue,
-            OklabHue::new(264.0520206380550121),
-            epsilon = 1e-12
-        );
+        assert_abs_diff_eq!(okhsv_blue_64.hue, expected_hue, epsilon = 1e-12);
         assert_abs_diff_eq!(
             okhsv_blue_64.saturation,
-            0.9999910912349018,
+            expected_saturation,
             epsilon = 1e-12
         );
-        assert_abs_diff_eq!(okhsv_blue_64.value, 0.9999999646150918, epsilon = 1e-12);
+        assert_abs_diff_eq!(okhsv_blue_64.value, expected_value, epsilon = 1e-12);
     }
 
     #[test]

palette/src/random_sampling.rs

@@ -67,6 +67,7 @@ pub(crate) mod test_utils {
     }
 
     fn approximate_gamma(z: f64) -> f64 {
+        #[allow(clippy::excessive_precision)]
         const RECIP_E: f64 = 0.36787944117144232159552377016147; // RECIP_E = (E^-1) = (1.0 / E)
         const TWOPI: f64 = core::f64::consts::TAU;
 

palette/src/random_sampling/cone.rs

@@ -186,6 +186,7 @@ mod test {
     }
 
     #[cfg(feature = "random")]
+    #[allow(clippy::excessive_precision)]
     #[test]
     fn hsl_sampling() {
         // Sanity check that sampling and inverting from sample are equivalent
@@ -216,6 +217,7 @@ mod test {
     }
 
     #[cfg(feature = "random")]
+    #[allow(clippy::excessive_precision)]
     #[test]
     fn hsluv_sampling() {
         // Sanity check that sampling and inverting from sample are equivalent