Fix clippy::pedantic lints

Author: Techcable

Cargo.toml

@@ -6,6 +6,11 @@ authors = ["Techcable <git@techcable.net>"]
 license = "Apache-2.0 OR MIT"
 edition = "2024"
 repository = "https://github.com/DuckLogic/qbe-parser.rs"
+keywords = ["qbe", "ir", "parser"]
+categories = [
+    "parser-implementations",
+    "compilers",
+]
 
 [dependencies]
 equivalent = "1"
@@ -25,3 +30,45 @@ chumsky = "0.11"
 [dev-dependencies]
 indoc = "2"
 similar-asserts = "1"
+
+[lints.clippy]
+## groups ##
+cargo = { priority = -1, level = "warn" }
+pedantic = { level = "warn", priority = -1 }
+
+# restrictions
+redundant_test_prefix = "warn" # name test_foo is redundant with #[test] attr
+
+# safety
+undocumented_unsafe_blocks = "deny"
+multiple_unsafe_ops_per_block = "deny"
+
+## aggressively lint casts ##
+# in an ideal world, overflowing casts would panic
+# linting them (with deny) is the second best option
+cast-possible-truncation = "deny"
+cast-possible-wrap = "deny"
+cast-precision-loss = "deny"
+cast-sign-loss = "deny"
+char-lit-as-u8 = "deny"
+cast-ptr-alignment = "deny"
+fn-to-numeric-cast = "deny"
+fn-to-numeric-cast-any = "deny"
+fn-to-numeric-cast-with-truncation = "deny"
+cast-lossless = "allow" # lossless casts are fine, lints will catch if types change
+ptr_as_ptr = "allow" # pointer casts are fine as long as they don't violate another rule
+
+#
+# excessively pedantic (even for clippy::pedantic)
+#
+too-many-lines = "allow"
+# We don't put #[must_use] on len
+must-use-candidate = "allow"
+return-self-not-must-use = "allow"
+items-after-statements = "allow"
+redundant-else = "allow"
+if-not-else = "allow"
+missing-errors-doc = "allow"
+wildcard-imports = "allow"
+single-match-else = "allow"
+trivially-copy-pass-by-ref = "allow"

src/ast/core.rs

@@ -131,6 +131,14 @@ impl Ident {
     pub fn unspanned(text: impl Into<AstString>) -> Self {
         Self::new(text, Span::MISSING)
     }
+    /// Create an identifier from a string.
+    ///
+    /// This accepts keywords without errors.
+    /// Using the `From<Keyword>` implementation does the same thing,
+    /// but more explicitly.
+    ///
+    /// # Panics
+    /// If the characters are not valid, this will panic.
     #[inline]
     #[track_caller]
     pub fn new(text: impl Into<AstString>, span: Span) -> Self {
@@ -139,20 +147,22 @@ impl Ident {
         let first = chars
             .next()
             .unwrap_or_else(|| panic!("Identifier is empty at {span:?}"));
-        if !is_xid_start(first) {
-            panic!("Invalid start char {first:?} for ident at {span:?}")
-        }
+        assert!(
+            is_xid_start(first),
+            "Invalid start char {first:?} for ident at {span:?}"
+        );
         for other in chars {
-            if !is_xid_continue(other) {
-                panic!("Invalid char {other:?} for ident at {span:?}")
-            }
+            assert!(
+                is_xid_continue(other),
+                "Invalid char {other:?} for ident at {span:?}"
+            );
         }
         if let Ok(byte_len) = span.byte_len() {
             assert_eq!(
                 byte_len,
                 text.len() as u64,
                 "Length of span {span} doesn't match {text:?}"
-            )
+            );
         }
         Ident { text, span }
     }

src/ast/functions.rs

@@ -36,14 +36,14 @@ impl FunctionDef {
                     if index > 0 {
                         res.push(InvalidFunctionReason::EnvironmentParamMustComeFirst {
                             span: param.span(),
-                        })
+                        });
                     }
                 }
                 ParamDef::Variadic(_) => {
                     if index < self.params.len() - 1 {
                         res.push(InvalidFunctionReason::VariadicParamMustComeLast {
                             span: param.span(),
-                        })
+                        });
                     }
                 }
             }
@@ -511,7 +511,7 @@ impl Display for JumpInstruction {
     fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
         match self {
             JumpInstruction::Jump { span: _, target } => {
-                write!(f, "jmp {}", target)
+                write!(f, "jmp {target}")
             }
             JumpInstruction::JumpNonZero {
                 span: _,
@@ -547,7 +547,7 @@ impl Display for UnknownInstructionNameError {
     fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
         f.write_str("Unknown")?;
         if let Some(kind) = self.kind_desc {
-            write!(f, " {}", kind)?;
+            write!(f, " {kind}")?;
         }
         write!(f, " instruction name: {:?}", self.name)
     }

src/ast/linkage.rs

@@ -115,7 +115,7 @@ impl Linkage {
         for entry in &self.specifiers {
             if entry.kind() == kind {
                 assert!(res.is_none(), "Internal Error: Duplicate {kind:?} entries");
-                res = Some(entry)
+                res = Some(entry);
             }
         }
         res
@@ -462,7 +462,7 @@ mod test {
                 .with_thread()
                 .with_section_and_flags("foo", "flags")
                 .build(),
-        )
+        );
     }
 
     #[test]

src/ast/span.rs

@@ -129,7 +129,7 @@ impl Default for Location {
 
 /// References a range of bytes in the original source file.
 ///
-/// Can be ["missing"](Span::MISSING),
+/// Can be [missing](Span::MISSING),
 /// in which case doesn't correspond to any actual portion of the source file.
 /// This is the [`Default`] value.
 ///
@@ -168,9 +168,7 @@ impl Span {
     #[track_caller]
     pub fn new(start: Location, end: Location) -> Span {
         // don't use assert! because missing locations will return false
-        if start > end {
-            panic!("start > end: {start} > {end}");
-        }
+        assert!(start <= end, "start > end: {start} > {end}");
         Span { start, end }
     }
 
@@ -566,6 +564,7 @@ impl ResolvedLocation {
         self.original
     }
 }
+#[allow(clippy::missing_fields_in_debug, reason = "intentional")]
 impl Debug for ResolvedLocation {
     fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
         if self.is_missing() {

src/ast/types/test.rs

@@ -52,7 +52,7 @@ fn parse_struct() {
             body: TypeDefBody::Struct(struct1_body()),
             align: None,
         }
-    )
+    );
 }
 
 #[test]
@@ -75,7 +75,7 @@ fn print_struct() {
             }
         "}
         .trim_end()
-    )
+    );
 }
 
 fn union1_body() -> UnionBody {
@@ -121,7 +121,7 @@ fn parse_union() {
             }),
             body: TypeDefBody::Union(union1_body()),
         }
-    )
+    );
 }
 
 #[test]
@@ -149,7 +149,7 @@ fn print_union() {
             }
         "}
         .trim_end()
-    )
+    );
 }
 
 fn opaque1() -> TypeDef {
@@ -172,10 +172,10 @@ fn parse_opaque_type() {
     assert_eq!(
         "type :hello = align 8 { 12 }".parse::<TypeDef>().unwrap(),
         opaque1(),
-    )
+    );
 }
 
 #[test]
 fn print_opaque_type() {
-    assert_eq!(format!("{}", opaque1()), "type :hello = align 8 { 12 }")
+    assert_eq!(format!("{}", opaque1()), "type :hello = align 8 { 12 }");
 }

src/lexer.rs

@@ -173,7 +173,7 @@ fn floating_point_value<'a>() -> impl StringParser<'a, NumericLiteral<OrderedFlo
 }
 /// Parse a single ASCII newline.
 ///
-/// Unlike text::newline, this only accepts ASCII newline operators
+/// Unlike [`text::newline`], this only accepts ASCII newline operators
 /// that would be recognized by [`str::lines`] ("\r\n" and "\n").
 ///
 /// TODO: Contribute this to chumsky?
@@ -410,7 +410,7 @@ mod test {
                 res.into_output(),
                 Some(text),
                 "Parse should succeed even with invalid whitespace"
-            )
+            );
         }
         let iws = inline_whitespace(); // primary parser being tested
         let iws = &iws;
@@ -466,7 +466,7 @@ mod test {
                 keyword!(type).into(),
                 Token::Newline,
             ])
-        )
+        );
     }
 
     #[test]
@@ -527,7 +527,7 @@ mod test {
         assert_eq!(
             tokenize("d_5.8 s_1.0").unwrap(),
             tokens([double(5.8), single(1.0)])
-        )
+        );
     }
 
     #[test]
@@ -540,7 +540,7 @@ mod test {
                 TemporaryName::unspanned("baz").into(),
                 BlockName::unspanned("foo").into(),
             ]
-        )
+        );
     }
 
     #[test]
@@ -567,6 +567,6 @@ mod test {
                 operator!(,).into(),
                 Token::Number(1.into()),
             ]
-        )
+        );
     }
 }

src/lexer/tokens.rs

@@ -188,11 +188,11 @@ const _TOKEN_USED: () = {
 };
 
 macro_rules! define_keyword_enum {
-    (enum $target:ident {
+    ($evis:vis enum $target:ident {
         $($kw:ident),+ $(,)?
     }) => {
         paste3::paste! {
-            define_string_enum!(enum $target {
+            define_string_enum!($evis enum $target {
                 $($kw([<$kw:snake>])),*
             });
         }

src/print.rs

@@ -60,7 +60,7 @@ impl<'a> IndentedPrinter<'a> {
     fn flush(&mut self) -> fmt::Result {
         if !self.buffer.is_empty() {
             self.output.write_str(&self.buffer)?;
-            self.buffer.clear()
+            self.buffer.clear();
         }
         Ok(())
     }