lint: use expect instead of allow

Avoid stale lint.
Only keep one allows due to macro codegen.

Author: grim7reaper

src/base_cell.rs

@@ -140,7 +140,7 @@ impl BaseCell {
             .iter()
             .position(|&cell| u8::from(neighbor) == cell)
             .map(|dir| {
-                #[allow(
+                #[expect(
                     clippy::cast_possible_truncation,
                     reason = "Cast safe thx to bounds"
                 )]
@@ -200,7 +200,7 @@ 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(
+#[expect(
     clippy::unusual_byte_groupings,
     reason = "Grouping by 3 is more explicit here"
 )]

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, reason = "on purpose")]
+        #[expect(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,7 @@ impl FaceIJK {
 
     /// Returns the number of 60° counterclockwise rotations to rotate into the
     /// coordinate system of the base cell at that coordinates.
-    #[allow(
+    #[expect(
         clippy::cast_sign_loss,
         reason = "safe because components values are in [0; 2]"
     )]
@@ -537,7 +537,7 @@ impl FaceIJK {
 /// current base cell.
 ///
 /// Returns the adjusted `IJK` coordinates.
-#[allow(
+#[expect(
     clippy::inline_always,
     reason = "4-5% boost, up to 13% at resolution 1."
 )]

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, reason = "on purpose")]
+    #[expect(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, reason = "on purpose")]
+    #[expect(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,7 +290,7 @@ impl TryFrom<CoordIJK> for Direction {
 
         // First, make sure we have a unit vector in `ijk`.
         if (value.i | value.j | value.k) & !1 == 0 {
-            #[allow(
+            #[expect(
                 clippy::cast_possible_truncation,
                 clippy::cast_sign_loss,
                 reason = "cannot truncate thx to check above (unit vector)"

src/coord/localij.rs

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

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, reason = "on purpose")]
+        #[expect(clippy::cast_possible_truncation, reason = "on purpose")]
         let m1 = x1 as i32;
-        #[allow(clippy::cast_possible_truncation, reason = "on purpose")]
+        #[expect(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, reason = "not gonna change any time soon")]
+#[expect(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, reason = "only used internally")]
+    #[expect(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

@@ -6,6 +6,7 @@ macro_rules! invalid_value_error {
         #[doc = concat!("Invalid ", $name, ".")]
         #[derive(Clone, Copy, Debug, PartialEq)]
         #[allow(
+            clippy::allow_attributes,
             clippy::derive_partial_eq_without_eq,
             reason = "value type may not be `Eq` (e.g. f64)"
         )]

src/face.rs

@@ -20,7 +20,10 @@ impl Face {
     /// # Safety
     ///
     /// The value must be a valid face.
-    #[allow(clippy::cast_possible_truncation, reason = "cannot because assert")]
+    #[expect(
+        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,7 +137,7 @@ impl FaceSet {
     /// ```
     pub fn iter(self) -> impl Iterator<Item = Face> {
         (0..NUM_ICOSA_FACES).filter_map(move |offset| {
-            #[allow(
+            #[expect(
                 clippy::cast_possible_truncation,
                 reason = "bounded by NUM_ICOSA_FACES"
             )]

src/geom/ring_hierarchy.rs

@@ -131,7 +131,7 @@ 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(
+        #[expect(
             clippy::filter_map_bool_then,
             reason = "borrow issue if filter+map"
         )]
@@ -160,7 +160,7 @@ 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(
+        #[expect(
             clippy::filter_map_bool_then,
             reason = "borrow issue if filter+map"
         )]

src/geom/tiler.rs

@@ -254,7 +254,7 @@ impl Tiler {
     ) -> Vec<(CellIndex, bool)> {
         // IIUC, the collect is necessary to consume the iterator and release
         // the mutable borrow on `already_seen`.
-        #[allow(
+        #[expect(
             clippy::needless_collect,
             reason = "needed because mutable borrow"
         )]
@@ -556,7 +556,7 @@ fn get_edge_cells(
         let count = line_hex_estimate(&line, resolution);
 
         assert!(count <= 1 << f64::MANTISSA_DIGITS);
-        #[allow(
+        #[expect(
             clippy::cast_precision_loss,
             reason = "cannot happen thanks to assert above"
         )]
@@ -607,7 +607,7 @@ fn line_hex_estimate(line: &Line, resolution: Resolution) -> u64 {
     let dist_ceil = (distance / pentagon_diameter).ceil();
     assert!(dist_ceil.is_finite());
 
-    #[allow(
+    #[expect(
         clippy::cast_possible_truncation,
         clippy::cast_sign_loss,
         reason = "truncate on purpose"
@@ -658,13 +658,13 @@ pub fn bbox_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, reason = "false positive")]
+    #[expect(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();
 
-    #[allow(
+    #[expect(
         clippy::cast_possible_truncation,
         clippy::cast_sign_loss,
         reason = "truncate on purpose"

src/index/bits.rs

@@ -20,7 +20,6 @@ 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, 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 +38,6 @@ pub const fn set_mode(bits: u64, mode: IndexMode) -> u64 {
 }
 
 /// Returns the H3 index cell edge bits.
-#[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 +56,6 @@ pub const fn clr_edge(bits: u64) -> u64 {
 }
 
 /// Returns the H3 index cell vertex bits.
-#[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 +131,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, reason = "values are in range")]
+    #[expect(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

@@ -113,10 +113,6 @@ 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,
-    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;
@@ -458,7 +454,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, reason = "12.5% faster")]
+    #[expect(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()));
@@ -574,7 +570,7 @@ impl CellIndex {
         mut position: u64,
         resolution: Resolution,
     ) -> Option<Self> {
-        #[allow(
+        #[expect(
             clippy::cast_possible_truncation,
             reason = "safe thx to assert"
         )]
@@ -2002,7 +1998,6 @@ 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, 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

@@ -152,6 +152,7 @@
     clippy::all,
     clippy::cargo,
     clippy::pedantic,
+    clippy::allow_attributes,
     clippy::allow_attributes_without_reason,
     clippy::as_underscore,
     clippy::branches_sharing_code,

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, reason = "not gonna change any time soon")]
+#[expect(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, reason = "safe because of the iterator")]
+    #[expect(unsafe_code, reason = "safe because of the iterator")]
     #[must_use]
     pub fn range(
         start: Self,
@@ -295,10 +295,6 @@ impl Resolution {
     /// let avg_edge_len = h3o::Resolution::Three.edge_length_m();
     /// ```
     #[must_use]
-    #[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,
@@ -389,7 +385,7 @@ impl Resolution {
     /// # Safety
     ///
     /// The value must be a valid resolution.
-    #[allow(unsafe_code, reason = "safe because assert")]
+    #[expect(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!

tests/api/latlng.rs

@@ -43,7 +43,7 @@ fn debug() {
 }
 
 #[test]
-#[allow(clippy::float_cmp, reason = "on purpose")]
+#[expect(clippy::float_cmp, reason = "on purpose")]
 fn lat_lng() {
     let lat = 2.349014;
     let lng = 48.864716;