clippy

Author: grim7reaper

src/base_cell.rs

@@ -140,8 +140,10 @@ impl BaseCell {
             .iter()
             .position(|&cell| u8::from(neighbor) == cell)
             .map(|dir| {
-                // Cast safe thx to bounds.
-                #[allow(clippy::cast_possible_truncation)]
+                #[allow(
+                    clippy::cast_possible_truncation,
+                    reason = "Cast safe thx to bounds"
+                )]
                 // SAFETY: `i` is bounded in [0; 6].
                 Direction::new_unchecked(dir as u8)
             })
@@ -198,7 +200,10 @@ impl fmt::Display for BaseCell {
 ///
 /// To reduce the footprints of the lookup table, we use a bitset where the
 /// rotation is encoded on 3-bit, where `111` means no rotation for this face.
-#[allow(clippy::unusual_byte_groupings)] // Grouping by 3 is more explicit here.
+#[allow(
+    clippy::unusual_byte_groupings,
+    reason = "Grouping by 3 is more explicit here"
+)]
 const BASE_CELL_ROTATIONS: [u64; BaseCell::count() as usize] = [
     // face 19  18  17  16  15  14  13  12  11  10  9   8   7   6   5   4   3   2   1   0
     0b1111_111_111_111_111_111_111_111_111_111_111_111_111_111_111_111_111_111_001_000_101,

src/coord/cube.rs

@@ -28,7 +28,7 @@ impl CoordCube {
         let j = f64::from(self.j) + offsets.1;
         let k = f64::from(self.k) + offsets.2;
 
-        #[allow(clippy::cast_possible_truncation)] // on purpose
+        #[allow(clippy::cast_possible_truncation, reason = "on purpose")]
         let (mut ri, mut rj, mut rk) =
             { (round(i) as i32, round(j) as i32, round(k) as i32) };
 

src/coord/faceijk.rs

@@ -38,7 +38,10 @@ impl FaceIJK {
 
     /// Returns the number of 60° counterclockwise rotations to rotate into the
     /// coordinate system of the base cell at that coordinates.
-    #[allow(clippy::cast_sign_loss)] // Safe because components values are in [0; 2].
+    #[allow(
+        clippy::cast_sign_loss,
+        reason = "safe because components values are in [0; 2]"
+    )]
     pub fn base_cell_rotation(&self) -> Rotation {
         // Should always be the case, or we have a nasty bug to fix.
         debug_assert!(
@@ -534,7 +537,10 @@ impl FaceIJK {
 /// current base cell.
 ///
 /// Returns the adjusted `IJK` coordinates.
-#[allow(clippy::inline_always)] // 4-5% boost, up to 13% at resolution 1.
+#[allow(
+    clippy::inline_always,
+    reason = "4-5% boost, up to 13% at resolution 1."
+)]
 #[inline(always)]
 fn directions_bits_from_ijk(
     mut ijk: CoordIJK,

src/coord/ijk.rs

@@ -127,7 +127,7 @@ impl CoordIJK {
 
     /// Returns the normalized `IJK` coordinates of the indexing parent of a
     /// cell in an aperture 7 grid.
-    #[allow(clippy::cast_possible_truncation)] // On purpose.
+    #[allow(clippy::cast_possible_truncation, reason = "on purpose")]
     pub fn up_aperture7<const CCW: bool>(&self) -> Self {
         let CoordIJ { i, j } = self.into();
 
@@ -142,7 +142,7 @@ impl CoordIJK {
 
     /// Returns the normalized `IJK` coordinates of the indexing parent of a
     /// cell in an aperture 7 grid.
-    #[allow(clippy::cast_possible_truncation)] // On purpose.
+    #[allow(clippy::cast_possible_truncation, reason = "on purpose")]
     pub fn checked_up_aperture7<const CCW: bool>(&self) -> Option<Self> {
         let CoordIJ { i, j } = self.into();
 
@@ -290,8 +290,11 @@ impl TryFrom<CoordIJK> for Direction {
 
         // First, make sure we have a unit vector in `ijk`.
         if (value.i | value.j | value.k) & !1 == 0 {
-            // Cannot truncate thx to check above (unit vector).
-            #[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
+            #[allow(
+                clippy::cast_possible_truncation,
+                clippy::cast_sign_loss,
+                reason = "cannot truncate thx to check above (unit vector)"
+            )]
             let bits = (value.i << 2 | value.j << 1 | value.k) as u8;
 
             // SAFETY: thx to `normalize` we are guaranteed to have at most two

src/coord/localij.rs

@@ -191,7 +191,10 @@ impl TryFrom<LocalIJK> for CellIndex {
 /// current base cell.
 ///
 /// Returns the adjusted `IJK` coordinates.
-#[allow(clippy::inline_always)] // 4-5% boost, up to 13% at resolution 1.
+#[allow(
+    clippy::inline_always,
+    reason = "4-5% boost, up to 13% at resolution 1"
+)]
 #[inline(always)]
 pub fn checked_directions_bits_from_ijk(
     mut ijk: CoordIJK,

src/coord/vec2d.rs

@@ -155,9 +155,9 @@ impl From<Vec2d> for CoordIJK {
         let x1 = a1 + x2 / 2.;
 
         // Check if we have the center of a hex.
-        #[allow(clippy::cast_possible_truncation)] // on purpose.
+        #[allow(clippy::cast_possible_truncation, reason = "on purpose")]
         let m1 = x1 as i32;
-        #[allow(clippy::cast_possible_truncation)] // on purpose.
+        #[allow(clippy::cast_possible_truncation, reason = "on purpose")]
         let m2 = x2 as i32;
 
         // Otherwise round correctly.

src/direction.rs

@@ -49,7 +49,7 @@ const TO_VERTEX_PENTAGON: [Vertex; NUM_PENT_VERTS as usize] = [
 /// ```
 #[derive(Clone, Copy, Debug, Eq, PartialEq, Hash, Ord, PartialOrd)]
 #[repr(u8)]
-#[allow(clippy::exhaustive_enums)] // Not gonna change any time soon.
+#[allow(clippy::exhaustive_enums, reason = "not gonna change any time soon")]
 #[cfg_attr(
     feature = "serde",
     derive(serde_repr::Serialize_repr, serde_repr::Deserialize_repr)
@@ -107,7 +107,7 @@ impl Direction {
     /// # Safety
     ///
     /// The value must be a valid direction.
-    #[allow(unsafe_code)]
+    #[allow(unsafe_code, reason = "only used internally")]
     pub(crate) const fn new_unchecked(value: u8) -> Self {
         assert!(value <= MAX, "direction out of range");
         // SAFETY: range checked above.

src/error/invalid_value.rs

@@ -5,8 +5,10 @@ macro_rules! invalid_value_error {
     ($name:literal, $error:ident, $value_type:ty) => {
         #[doc = concat!("Invalid ", $name, ".")]
         #[derive(Clone, Copy, Debug, PartialEq)]
-        // Value type may not be `Eq` (e.g. f64).
-        #[allow(clippy::derive_partial_eq_without_eq)]
+        #[allow(
+            clippy::derive_partial_eq_without_eq,
+            reason = "value type may not be `Eq` (e.g. f64)"
+        )]
         pub struct $error {
             /// The invalid value.
             pub value: $value_type,

src/face.rs

@@ -20,7 +20,7 @@ impl Face {
     /// # Safety
     ///
     /// The value must be a valid face.
-    #[allow(clippy::cast_possible_truncation)]
+    #[allow(clippy::cast_possible_truncation, reason = "cannot because assert")]
     pub(crate) const fn new_unchecked(value: usize) -> Self {
         debug_assert!(value < NUM_ICOSA_FACES, "face out of range");
         Self(value as u8)
@@ -134,8 +134,10 @@ impl FaceSet {
     /// ```
     pub fn iter(self) -> impl Iterator<Item = Face> {
         (0..NUM_ICOSA_FACES).filter_map(move |offset| {
-            #[allow(clippy::cast_possible_truncation)]
-            // bounded by NUM_ICOSA_FACES.
+            #[allow(
+                clippy::cast_possible_truncation,
+                reason = "bounded by NUM_ICOSA_FACES"
+            )]
             (self.0 >> offset & 1 == 1).then_some(Face(offset as u8))
         })
     }

src/geom/geometry/bbox.rs

@@ -86,14 +86,17 @@ pub fn hex_estimate(bbox: &Rect, resolution: Resolution) -> usize {
     let (width, length) = if d1 < d2 { (d1, d2) } else { (d2, d1) };
     // Derived constant based on: https://math.stackexchange.com/a/1921940
     // Clamped to 3 as higher values tend to rapidly drag the estimate to zero.
-    #[allow(clippy::suspicious_operation_groupings)] // False positive.
+    #[allow(clippy::suspicious_operation_groupings, reason = "false positive")]
     let area = (diagonal * diagonal) / (length / width);
 
     // Divide the two to get an estimate of the number of hexagons needed.
     let estimate = (area / pentagon_area_rads2).ceil();
 
-    // Truncate on purpose.
-    #[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
+    #[allow(
+        clippy::cast_possible_truncation,
+        clippy::cast_sign_loss,
+        reason = "truncate on purpose"
+    )]
     let estimate = estimate as usize;
 
     core::cmp::max(estimate, 1)

src/geom/geometry/polygon.rs

@@ -163,7 +163,10 @@ impl Polygon {
     ) -> Vec<CellIndex> {
         // IIUC, the collect is necessary to consume the iterator and release
         // the mutable borrow on `already_seen`.
-        #[allow(clippy::needless_collect)]
+        #[allow(
+            clippy::needless_collect,
+            reason = "needed because mutable borrow"
+        )]
         // Compute the set of cells making the outlines of the polygon.
         let outlines = self
             .interiors()
@@ -441,8 +444,10 @@ fn get_edge_cells(
             let count = line_hex_estimate(&line, resolution);
 
             assert!(count <= 1 << f64::MANTISSA_DIGITS);
-            #[allow(clippy::cast_precision_loss)]
-            // Nope thanks to assert above.
+            #[allow(
+                clippy::cast_precision_loss,
+                reason = "cannot happen thanks to assert above"
+            )]
             (0..count).map(move |i| {
                 let i = i as f64;
                 let count = count as f64;
@@ -517,8 +522,11 @@ fn line_hex_estimate(line: &geo::Line<f64>, resolution: Resolution) -> u64 {
     let dist_ceil = (distance / pentagon_diameter).ceil();
     assert!(dist_ceil.is_finite());
 
-    // Truncate on purpose.
-    #[allow(clippy::cast_possible_truncation, clippy::cast_sign_loss)]
+    #[allow(
+        clippy::cast_possible_truncation,
+        clippy::cast_sign_loss,
+        reason = "truncate on purpose"
+    )]
     let estimate = dist_ceil as u64;
 
     cmp::max(estimate, 1)

src/geom/ring_hierarchy.rs

@@ -132,7 +132,10 @@ impl RingHierarchy {
     /// Note that in case of nested polygons, you may need to call this function
     /// several time to extract outer rings at every nesting level.
     fn peel_outers(&mut self) -> Option<Vec<(usize, LineString<f64>)>> {
-        #[allow(clippy::filter_map_bool_then)] // Borrow issue if filter+map
+        #[allow(
+            clippy::filter_map_bool_then,
+            reason = "borrow issue if filter+map"
+        )]
         let outers = (0..self.rings.len())
             .filter_map(|i| {
                 // Skip assigned rings and non-outer ones.
@@ -158,7 +161,10 @@ impl RingHierarchy {
     fn inners(&mut self, outer_id: usize) -> Vec<LineString<f64>> {
         // Walk by column to find candidate and then check their parents using
         // the row-order
-        #[allow(clippy::filter_map_bool_then)] // Borrow issue if filter+map
+        #[allow(
+            clippy::filter_map_bool_then,
+            reason = "borrow issue if filter+map"
+        )]
         let (ids, rings) = (0..self.rings.len())
             .filter_map(|inner_id| {
                 (!self.is_assigned[inner_id]

src/index/bits.rs

@@ -20,7 +20,7 @@ const VERTEX_MASK: u64 = 0b111 << VERTEX_OFFSET;
 pub const DIRECTIONS_MASK: u64 = 0x0000_1fff_ffff_ffff;
 
 /// Returns the H3 index mode  bits.
-#[allow(clippy::cast_possible_truncation)] // Cast safe thx to masking.
+#[allow(clippy::cast_possible_truncation, reason = "cast safe thx to masking")]
 #[must_use]
 pub const fn get_mode(bits: u64) -> u8 {
     ((bits & MODE_MASK) >> MODE_OFFSET) as u8
@@ -39,7 +39,7 @@ pub const fn set_mode(bits: u64, mode: IndexMode) -> u64 {
 }
 
 /// Returns the H3 index cell edge bits.
-#[allow(clippy::cast_possible_truncation)] // Cast safe thx to masking.
+#[allow(clippy::cast_possible_truncation, reason = "cast safe thx to masking")]
 #[must_use]
 pub const fn get_edge(bits: u64) -> u8 {
     ((bits & EDGE_MASK) >> EDGE_OFFSET) as u8
@@ -58,7 +58,7 @@ pub const fn clr_edge(bits: u64) -> u64 {
 }
 
 /// Returns the H3 index cell vertex bits.
-#[allow(clippy::cast_possible_truncation)] // Cast safe thx to masking.
+#[allow(clippy::cast_possible_truncation, reason = "cast safe thx to masking")]
 #[must_use]
 pub const fn get_vertex(bits: u64) -> u8 {
     ((bits & VERTEX_MASK) >> VERTEX_OFFSET) as u8
@@ -134,7 +134,7 @@ pub fn first_axe(bits: u64) -> Option<NonZeroU8> {
     let bit_index = (bits & DIRECTIONS_MASK).leading_zeros() - PREFIX_LENGTH;
 
     // +1 because the first direction is at resolution 1, not 0.
-    #[allow(clippy::cast_possible_truncation)] // Values are in range.
+    #[allow(clippy::cast_possible_truncation, reason = "values are in range")]
     let resolution = cmp::min(
         ((bit_index / h3o_bit::DIRECTION_BITSIZE as u32) + 1) as u8,
         resolution.into(),

src/index/cell.rs

@@ -112,7 +112,10 @@ const PENTAGON_ROTATIONS: [[u8; 7]; 7] = [
 /// due to failure cases. It's possible this could be restricted to a narrower
 /// set of a failure cases. Currently, the logic is any unfolding across more
 /// than one icosahedron face is not permitted.
-#[allow(clippy::unusual_byte_groupings)] // Grouping by 7 is more explicit here.
+#[allow(
+    clippy::unusual_byte_groupings,
+    reason = "grouping by 7 is more explicit here"
+)]
 const FAILED_DIRECTIONS: u64 =
     //   6       5       4       3       2       1       0
     0b0101000_1000100_0001100_1010000_0110000_0000000_0000000;
@@ -454,7 +457,7 @@ impl CellIndex {
     // In this case, `mut-let-if` is faster than the idiomatic `let-if-else`.
     // Actually 12.5% faster for hexagons and 3.5% slower for pentagons.
     // Given that hexagons are way more common than pentagons, worth it.
-    #[allow(clippy::useless_let_if_seq)]
+    #[allow(clippy::useless_let_if_seq, reason = "12.5% faster")]
     pub fn children_count(self, resolution: Resolution) -> u64 {
         let resolution = usize::from(resolution);
         let curr_resolution = usize::from(bits::get_resolution(self.0.get()));
@@ -570,7 +573,10 @@ impl CellIndex {
         mut position: u64,
         resolution: Resolution,
     ) -> Option<Self> {
-        #[allow(clippy::cast_possible_truncation)] // Safe thx to assert.
+        #[allow(
+            clippy::cast_possible_truncation,
+            reason = "safe thx to assert"
+        )]
         fn set_direction(bits: u64, digit: u64, resolution: Resolution) -> u64 {
             assert!(digit < 7);
             bits::set_direction(bits, digit as u8, resolution)
@@ -1947,7 +1953,7 @@ impl<'a> arbitrary::Arbitrary<'a> for CellIndex {
 /// Checks if there is at least one unused direction in the given directions.
 #[inline(always)]
 #[rustfmt::skip] // Keep constants aligned for readability.
-#[allow(clippy::unusual_byte_groupings)] // Grouping by 3-bit is better here.
+#[allow(clippy::unusual_byte_groupings, reason = "grouping by 3-bit is better here")]
 const fn has_unused_direction(dirs: u64) -> bool {
     // Unused directions are represented by `0b111`, so we actually want to
     // check the absence of this pattern.

src/lib.rs

@@ -8,16 +8,16 @@
 //! ## Crate features
 //!
 //! * **std** -
-//! When enabled, this will cause `h3o` to use the standard library. In terms of
-//! APIs, `std` causes error types to implement the `std::error::Error` trait.
-//! Enabling `std` will also result in performance optimizations.
+//!     When enabled, this will cause `h3o` to use the standard library. In terms of
+//!     APIs, `std` causes error types to implement the `std::error::Error` trait.
+//!     Enabling `std` will also result in performance optimizations.
 //!
 //! * **geo** -
-//! When enabled, you'll be able to convert lists of H3 cell indexes from and
-//! into geometric shapes. Also enables the `GeoJSON` support. Requires `std`.
+//!     When enabled, you'll be able to convert lists of H3 cell indexes from and
+//!     into geometric shapes. Also enables the `GeoJSON` support. Requires `std`.
 //!
 //! * **serde** -
-//! When enabled, H3 index types (cell, vertex and edge) derive serde traits.
+//!     When enabled, H3 index types (cell, vertex and edge) derive serde traits.
 //!
 //! ## H3 to H3O mapping
 //!
@@ -243,6 +243,7 @@
     clippy::unreadable_literal,
     // Too many irrelevant warning (about internal invariants).
     clippy::missing_panics_doc,
+    reason = "allow some exceptions"
 )]
 // }}}
 

src/resolution.rs

@@ -4,7 +4,7 @@ use core::{ffi::c_int, fmt, iter::DoubleEndedIterator, str::FromStr};
 /// Cell resolution, from 0 to 15.
 #[derive(Clone, Copy, Debug, Eq, PartialEq, Hash, Ord, PartialOrd)]
 #[repr(u8)]
-#[allow(clippy::exhaustive_enums)] // Not gonna change any time soon.
+#[allow(clippy::exhaustive_enums, reason = "not gonna change any time soon")]
 #[cfg_attr(
     feature = "serde",
     derive(serde_repr::Serialize_repr, serde_repr::Deserialize_repr)
@@ -125,7 +125,7 @@ impl Resolution {
     ///               .collect::<Vec<_>>();
     /// assert_eq!(res, vec![Resolution::Two, Resolution::One, Resolution::Zero]);
     /// ```
-    #[allow(unsafe_code)]
+    #[allow(unsafe_code, reason = "safe because of the iterator")]
     #[must_use]
     pub fn range(
         start: Self,
@@ -295,8 +295,10 @@ impl Resolution {
     /// let avg_edge_len = h3o::Resolution::Three.edge_length_m();
     /// ```
     #[must_use]
-    // I don't want to group digits of the decimal part.
-    #[allow(clippy::inconsistent_digit_grouping)]
+    #[allow(
+        clippy::inconsistent_digit_grouping,
+        reason = "don't want to group digits of the decimal part"
+    )]
     pub const fn edge_length_m(self) -> f64 {
         match self {
             Self::Zero => 1281256.0107413644,
@@ -387,7 +389,7 @@ impl Resolution {
     /// # Safety
     ///
     /// The value must be a valid resolution.
-    #[allow(unsafe_code)]
+    #[allow(unsafe_code, reason = "safe because assert")]
     pub(crate) const fn new_unchecked(value: u8) -> Self {
         assert!(value <= h3o_bit::MAX_RESOLUTION, "resolution out of range");
         // SAFETY: range is checked above!