(main) ref: better handling of clippy lints

Author: t-webber

Cargo.toml

@@ -6,11 +6,16 @@ authors = ["Tom Webber"]
 license-file = "LICENSE"
 repository = "https://www.github.com/t-webber/c-parser"
 description = "A rust library to lex and parse C source files into Abstract Syntax Trees."
-publish = false
 keywords = ["parsing", "lexing", "compiling", "nostd"]
-categories = ["compilers", "no-std", "no-std::alloc", "parser-implementations", "parsing"]
-
-[dependencies]
+readme = "docs/README.md"
+categories = [
+  "compilers",
+  "no-std",
+  "no-std::alloc",
+  "parser-implementations",
+  "parsing",
+]
 
 [features]
-debug = []
+debug = []
+

src/errors/compile.rs

@@ -51,7 +51,6 @@ impl CompileError {
 }
 
 impl From<(ErrorLocation, String, ErrorLevel)> for CompileError {
-    #[inline]
     fn from((location, message, err_lvl): (ErrorLocation, String, ErrorLevel)) -> Self {
         Self {
             err_lvl,
@@ -108,7 +107,7 @@ pub enum ErrorLevel {
     Warning,
 }
 
-#[expect(clippy::min_ident_chars)]
+#[expect(clippy::min_ident_chars, reason = "don't rename trait's method params")]
 #[coverage(off)]
 impl fmt::Display for ErrorLevel {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {

src/errors/location.rs

@@ -190,7 +190,6 @@ impl LocationPointer {
 }
 
 impl<T: ToString> From<T> for LocationPointer {
-    #[inline]
     fn from(file: T) -> Self {
         Self {
             col: 0,

src/errors/mod.rs

@@ -7,7 +7,7 @@
 pub mod api {
     //! Api module to choose what functions to export.
 
-    #![allow(clippy::pub_use)]
+    #![allow(clippy::pub_use, reason = "expose simple API")]
 
     pub use super::compile::CompileError;
     #[cfg(feature = "debug")]

src/errors/result.rs

@@ -66,7 +66,6 @@ impl<T: fmt::Debug> Res<T> {
     /// # Panics
     ///
     /// If there are too many errors, a buffer overflow occurs
-    #[inline]
     pub fn as_displayed_errors(&self, files: &[(String, &str)], err_type: &str) -> String {
         display_errors(&self.errors, files, err_type)
             .expect("Buffer overflow, failed to fetch errors")
@@ -83,7 +82,6 @@ impl<T: fmt::Debug> Res<T> {
     /// ```ignore
     /// assert!(Res::from_errs(vec![]).errors_empty() == true);
     /// ```
-    #[inline]
     pub const fn errors_empty(&self) -> bool {
         self.errors.is_empty()
     }
@@ -117,9 +115,8 @@ impl<T: fmt::Debug> Res<T> {
     /// # Panics
     ///
     /// If there is at least one error of level `Failure`.
-    #[inline]
     #[coverage(off)]
-    #[expect(clippy::print_stderr)]
+    #[expect(clippy::print_stderr, reason = "goal of function")]
     pub fn unwrap_or_display(self, files: &[(String, &str)], err_type: &str) -> T {
         eprint!("{}", self.as_displayed_errors(files, err_type));
         #[cfg(feature = "debug")]
@@ -135,7 +132,6 @@ impl<T: fmt::Debug> Res<T> {
 }
 
 impl<T: Default> From<CompileError> for Res<T> {
-    #[inline]
     fn from(err: CompileError) -> Self {
         Self {
             result: T::default(),
@@ -145,14 +141,12 @@ impl<T: Default> From<CompileError> for Res<T> {
 }
 
 impl<T> From<(T, Vec<CompileError>)> for Res<T> {
-    #[inline]
     fn from((result, errors): (T, Vec<CompileError>)) -> Self {
         Self { errors, result }
     }
 }
 
 impl<T> From<T> for Res<T> {
-    #[inline]
     fn from(value: T) -> Self {
         Self {
             result: value,
@@ -162,7 +156,6 @@ impl<T> From<T> for Res<T> {
 }
 
 impl<T: Default + fmt::Debug> ops::FromResidual<Vec<CompileError>> for Res<T> {
-    #[inline]
     fn from_residual(residual: Vec<CompileError>) -> Self {
         Self {
             errors: residual,
@@ -172,7 +165,6 @@ impl<T: Default + fmt::Debug> ops::FromResidual<Vec<CompileError>> for Res<T> {
 }
 
 impl<T: Default> ops::FromResidual<Result<convert::Infallible, CompileError>> for Res<T> {
-    #[inline]
     #[coverage(off)]
     fn from_residual(residual: Result<convert::Infallible, CompileError>) -> Self {
         match residual {
@@ -186,7 +178,6 @@ impl<T: Default + fmt::Debug> ops::Try for Res<T> {
     type Output = T;
     type Residual = Vec<CompileError>;
 
-    #[inline]
     fn branch(self) -> ops::ControlFlow<Self::Residual, Self::Output> {
         if self.errors.is_empty() {
             ops::ControlFlow::Continue(self.result)
@@ -195,7 +186,6 @@ impl<T: Default + fmt::Debug> ops::Try for Res<T> {
         }
     }
 
-    #[inline]
     #[coverage(off)]
     fn from_output(output: Self::Output) -> Self {
         Self::from(output)

src/lexer/lex_content.rs

@@ -12,7 +12,7 @@ use crate::errors::api::{IntoError as _, LocationPointer, Res};
 ///
 /// This function updates the [`LS`] automaton, and executes the right
 /// handlers.
-#[expect(clippy::too_many_lines)]
+#[expect(clippy::too_many_lines, reason = "no sense in breaking that logic")]
 fn lex_char(
     ch: char,
     location: &LocationPointer,
@@ -152,7 +152,6 @@ fn lex_char(
 /// functions. Every character is parsed one by one, and the state is modified
 /// accordingly. When the state changes, the buffers of the state are empty into
 /// the data.
-#[inline]
 pub fn lex_file(content: &str, location: &mut LocationPointer) -> Res<Vec<Token>> {
     let mut lex_data = LexingData::default();
     let mut lex_state = LS::default();

src/lexer/mod.rs

@@ -5,7 +5,7 @@
 pub mod api {
     //! Api module to choose what functions to export.
 
-    #![allow(clippy::pub_use)]
+    #![allow(clippy::pub_use, reason = "expose simple API")]
 
     pub use super::lex_content::lex_file;
     pub use super::numbers::api::Number;

src/lexer/numbers/base/hexadecimal.rs

@@ -1,6 +1,6 @@
 //! Module to parse hexadecimal-represented number constants
 
-#![allow(clippy::arbitrary_source_item_ordering)]
+#![allow(clippy::arbitrary_source_item_ordering, reason = "macro usage")]
 
 use core::num::{IntErrorKind, ParseIntError};
 
@@ -15,7 +15,7 @@ use crate::lexer::numbers::types::{ERR_PREFIX, Number, NumberType};
 /// Implements the [`FloatingPoint`] for the floating-point types.
 macro_rules! impl_floating_point {
     ($x:expr, $($type:ident)*) => {
-        $(#[allow(clippy::as_conversions, clippy::cast_precision_loss, clippy::allow_attributes)]
+        $(#[allow(clippy::as_conversions, clippy::cast_precision_loss, clippy::allow_attributes, reason="todo")]
         impl FloatingPoint<${concat($type, IntPart)}> for $type {
             const MANTISSA_SIZE: u32 = $x;
 
@@ -49,7 +49,7 @@ macro_rules! impl_floating_point {
 /// Parses the stringified version of a number into a [`HexFloatData`].
 macro_rules! parse_hexadecimal_float {
     ($overflow:expr, $nb_type:ident, $float_parse:ident, $($t:ident)*) => {{
-        #[expect(clippy::float_arithmetic, clippy::arithmetic_side_effects, clippy::as_conversions)]
+        #[expect(clippy::float_arithmetic, clippy::arithmetic_side_effects, clippy::as_conversions, reason="todo")]
         match $nb_type {
             $(NumberType::$t => {
                 let int_part = $t::from_unsigned(

src/lexer/numbers/macros.rs

@@ -1,7 +1,6 @@
 //! Module that defines useful macros to parse integer and get useful errors.
 
-#![allow(clippy::arbitrary_source_item_ordering)]
-#![allow(clippy::pub_use)]
+#![allow(clippy::arbitrary_source_item_ordering, reason = "macro usage")]
 
 /// Parses an integer from a given base
 ///

src/lexer/numbers/mod.rs

@@ -17,7 +17,7 @@
 pub mod api {
     //! Api module to choose what functions to export.
 
-    #![allow(clippy::pub_use)]
+    #![allow(clippy::pub_use, reason = "expose simple API")]
 
     pub use super::from_literal::literal_to_number;
     pub use super::parse::OverParseRes;