Add our clippy lints.

Author: Alexhuszagh

clippy.toml

@@ -0,0 +1,20 @@
+avoid-breaking-exported-api = false
+disallowed-macros = [
+    # Can also use an inline table with a `path` key.
+    { path = "std::print", reason = "no IO allowed" },
+    { path = "std::println", reason = "no IO allowed" },
+    { path = "std::format", reason = "no string allocation allowed" },
+    { path = "std::debug", reason = "debugging macros should not be present in any release" },
+    # NOTE: unimplemented is fine because this can be for intentionally disabled methods
+    { path = "std::todo", reason = "should never have TODO macros in releases" },
+]
+disallowed-methods = [
+    { path = "std::io::stdout", reason = "no IO allowed" },
+    { path = "std::io::stdin", reason = "no IO allowed" },
+    { path = "std::io::stderr", reason = "no IO allowed" },
+]
+disallowed-types = [
+    { path = "std::io::File", reason = "no IO allowed" },
+    { path = "std::io::BufReader", reason = "need our own abstractions for reading/writing" },
+    { path = "std::io::BufWriter", reason = "need our own abstractions for reading/writing" },
+]

src/binary.rs

@@ -17,7 +17,7 @@ pub fn compute_float<F: Float>(q: i64, mut w: u64) -> AdjustedMantissa {
     w <<= lz;
     let (lo, hi) = compute_product_approx(q, w, F::MANTISSA_EXPLICIT_BITS + 3);
     if lo == 0xFFFF_FFFF_FFFF_FFFF {
-        let inside_safe_exponent = (q >= -27) && (q <= 55);
+        let inside_safe_exponent = (-27..=55).contains(&q);
         if !inside_safe_exponent {
             return am_error;
         }

src/common.rs

@@ -14,7 +14,7 @@ impl<'a> AsciiStr<'a> {
         Self {
             ptr: s.as_ptr(),
             end: unsafe { s.as_ptr().add(s.len()) },
-            _marker: PhantomData::default(),
+            _marker: PhantomData,
         }
     }
 
@@ -72,11 +72,11 @@ impl<'a> AsciiStr<'a> {
 
     #[inline]
     pub fn first(&self) -> Option<u8> {
-        if !self.is_empty() {
+        if self.is_empty() {
+            None
+        } else {
             // SAFETY: safe since `!self.is_empty()`
             Some(unsafe { self.first_unchecked() })
-        } else {
-            None
         }
     }
 
@@ -87,20 +87,12 @@ impl<'a> AsciiStr<'a> {
 
     #[inline]
     pub fn first_is2(&self, c1: u8, c2: u8) -> bool {
-        if let Some(c) = self.first() {
-            c == c1 || c == c2
-        } else {
-            false
-        }
+        self.first().map_or(false, |c| c == c1 || c == c2)
     }
 
     #[inline]
     pub fn first_is_digit(&self) -> bool {
-        if let Some(c) = self.first() {
-            c.is_ascii_digit()
-        } else {
-            false
-        }
+        self.first().map_or(false, |c| c.is_ascii_digit())
     }
 
     #[inline]
@@ -116,13 +108,10 @@ impl<'a> AsciiStr<'a> {
 
     #[inline]
     pub fn try_read_digit(&mut self) -> Option<u8> {
-        if let Some(digit) = self.first_digit() {
-            // SAFETY: Safe since `first_digit` means the buffer is not empty
-            unsafe { self.step() };
-            Some(digit)
-        } else {
-            None
-        }
+        let digit = self.first_digit()?;
+        // SAFETY: Safe since `first_digit` means the buffer is not empty
+        unsafe { self.step() };
+        Some(digit)
     }
 
     #[inline]
@@ -145,6 +134,7 @@ impl<'a> AsciiStr<'a> {
     ///
     /// Safe if `self.len() >= 8`
     #[inline]
+    #[allow(clippy::cast_ptr_alignment)]
     pub unsafe fn read_u64_unchecked(&self) -> u64 {
         debug_assert!(self.len() >= 8, "overflowing buffer: buffer is not 8 bytes long");
         let src = self.ptr as *const u64;
@@ -203,6 +193,7 @@ pub trait ByteSlice: AsRef<[u8]> + AsMut<[u8]> {
     ///
     /// Safe if `self.len() >= 8`.
     #[inline]
+    #[allow(clippy::cast_ptr_alignment)]
     unsafe fn read_u64(&self) -> u64 {
         debug_assert!(self.as_ref().len() >= 8);
         let src = self.as_ref().as_ptr() as *const u64;
@@ -214,6 +205,7 @@ pub trait ByteSlice: AsRef<[u8]> + AsMut<[u8]> {
     ///
     /// Safe if `self.len() >= 8`.
     #[inline]
+    #[allow(clippy::cast_ptr_alignment)]
     unsafe fn write_u64(&mut self, value: u64) {
         debug_assert!(self.as_ref().len() >= 8);
         let dst = self.as_mut().as_mut_ptr() as *mut u64;

src/decimal.rs

@@ -87,7 +87,7 @@ impl Decimal {
         if dp < self.num_digits {
             round_up = self.digits[dp] >= 5;
             if self.digits[dp] == 5 && dp + 1 == self.num_digits {
-                round_up = self.truncated || ((dp != 0) && (1 & self.digits[dp - 1] != 0))
+                round_up = self.truncated || ((dp != 0) && (1 & self.digits[dp - 1] != 0));
             }
         }
         if round_up {
@@ -267,6 +267,7 @@ pub fn parse_decimal(mut s: &[u8]) -> Decimal {
 }
 
 #[inline]
+#[allow(clippy::redundant_else)]
 fn number_of_digits_decimal_left_shift(d: &Decimal, mut shift: usize) -> usize {
     const TABLE: [u16; 65] = [
         0x0000, 0x0800, 0x0801, 0x0803, 0x1006, 0x1009, 0x100D, 0x1812, 0x1817, 0x181D, 0x2024,
@@ -326,7 +327,7 @@ fn number_of_digits_decimal_left_shift(d: &Decimal, mut shift: usize) -> usize {
     shift &= 63;
     let x_a = TABLE[shift];
     let x_b = TABLE[shift + 1];
-    let num_new_digits = (x_a >> 11) as _;
+    let num_new_digits = (x_a >> 11) as usize;
     let pow5_a = (0x7FF & x_a) as usize;
     let pow5_b = (0x7FF & x_b) as usize;
     let pow5 = &TABLE_POW5[pow5_a..];

src/float.rs

@@ -68,12 +68,12 @@ impl Float for f32 {
 
     #[inline]
     fn from_u64(v: u64) -> Self {
-        v as _
+        v as f32
     }
 
     #[inline]
     fn from_u64_bits(v: u64) -> Self {
-        f32::from_bits((v & 0xFFFFFFFF) as u32)
+        f32::from_bits((v & 0xFFFF_FFFF) as u32)
     }
 
     #[inline]
@@ -108,7 +108,7 @@ impl Float for f64 {
 
     #[inline]
     fn from_u64(v: u64) -> Self {
-        v as _
+        v as f64
     }
 
     #[inline]

src/lib.rs

@@ -12,13 +12,12 @@
 //!   returns an error if there are invalid characters or if the string is
 //!   empty.
 //! - [`parse_partial`](crate::parse_partial()) tries to find the longest
-//!   substring at the
-//! beginning of the given input string that can be parsed as a decimal number
-//! and, in the case of success, returns the parsed value along the number of
-//! characters processed; an error is returned if the string doesn't start with
-//! a decimal number or if it is empty. This function is most useful as a
-//! building block when constructing more complex parsers, or when parsing
-//! streams of data.
+//!   substring at the beginning of the given input string that can be parsed as
+//!   a decimal number and, in the case of success, returns the parsed value
+//!   along the number of characters processed; an error is returned if the
+//!   string doesn't start with a decimal number or if it is empty. This
+//!   function is most useful as a building block when constructing more complex
+//!   parsers, or when parsing streams of data.
 //!
 //! ## Examples
 //!
@@ -36,7 +35,17 @@
 //! assert_eq!(&s[n..], "foo");
 //! ```
 
+#![allow(unused_unsafe)]
+#![warn(unsafe_op_in_unsafe_fn)]
 #![warn(clippy::all, clippy::pedantic, clippy::nursery, clippy::cargo)]
+#![deny(
+    clippy::doc_markdown,
+    clippy::unnecessary_safety_comment,
+    clippy::semicolon_if_nothing_returned,
+    clippy::unwrap_used,
+    clippy::as_underscore,
+    clippy::doc_markdown
+)]
 #![allow(
     clippy::cast_possible_truncation,
     clippy::cast_possible_wrap,
@@ -46,7 +55,8 @@
     clippy::missing_const_for_fn,
     clippy::use_self,
     clippy::module_name_repetitions,
-    clippy::cargo_common_metadata
+    clippy::cargo_common_metadata,
+    clippy::struct_field_names
 )]
 
 use core::fmt::{self, Display};

src/number.rs

@@ -3,6 +3,7 @@ use crate::float::Float;
 
 const MIN_19DIGIT_INT: u64 = 100_0000_0000_0000_0000;
 
+#[allow(clippy::unreadable_literal)]
 pub const INT_POW10: [u64; 16] = [
     1,
     10,
@@ -46,9 +47,9 @@ impl Number {
                 // normal fast path
                 let value = F::from_u64(self.mantissa);
                 if self.exponent < 0 {
-                    value / F::pow10_fast_path((-self.exponent) as _)
+                    value / F::pow10_fast_path((-self.exponent) as usize)
                 } else {
-                    value * F::pow10_fast_path(self.exponent as _)
+                    value * F::pow10_fast_path(self.exponent as usize)
                 }
             } else {
                 // disguised fast path
@@ -57,7 +58,7 @@ impl Number {
                 if mantissa > F::MAX_MANTISSA_FAST_PATH {
                     return None;
                 }
-                F::from_u64(mantissa) * F::pow10_fast_path(F::MAX_EXPONENT_FAST_PATH as _)
+                F::from_u64(mantissa) * F::pow10_fast_path(F::MAX_EXPONENT_FAST_PATH as usize)
             };
             if self.negative {
                 value = -value;
@@ -201,7 +202,7 @@ pub fn parse_number(s: &[u8]) -> Option<(Number, usize)> {
     let exp_number = parse_scientific(&mut s);
     exponent += exp_number;
 
-    let len = s.offset_from(&start) as _;
+    let len = s.offset_from(&start) as usize;
 
     // handle uncommon case with many digits
     if n_digits <= 19 {

src/simple.rs

@@ -45,7 +45,7 @@ pub fn parse_long_mantissa<F: Float>(s: &[u8]) -> AdjustedMantissa {
                 _ => 1,
             }
         } else {
-            get_shift((-d.decimal_point) as _)
+            get_shift((-d.decimal_point) as usize)
         };
         d.left_shift(shift);
         if d.decimal_point > Decimal::DECIMAL_POINT_RANGE {