lint!: upgrade perfectionist (#412)

https://claude.ai/code/session_01CoRidYHvni9nKNgxMPXmfQ

---------

Co-authored-by: Claude <noreply@anthropic.com>

Author: KSXGitHub

.github/copilot-instructions.md

@@ -12,7 +12,6 @@ Read and follow the CONTRIBUTING.md file in this repository for all code style c
 - Use descriptive names for variables and closure parameters. Single letters are permitted only in these cases: (1) conventional names like `n` for count or `f` for formatter; (2) comparison closures like `|a, b|`; (3) trivial single-expression closures; (4) fold accumulators; (5) index variables `i`/`j`/`k` in short closures or index-based loops; and (6) test fixtures with identical roles. Single letters are never permitted in multi-line functions or closures.
 - Use `pipe-trait` to chain through unary functions such as constructors, `Some`, `Ok`, and free functions. Use it to flatten nested calls and to continue method chains. Do not use it for simple standalone calls; prefer `foo(value)` over `value.pipe(foo)`.
 - Prefer `where` clauses when a type has multiple trait bounds.
-- Derive order: standard traits, then comparison traits, then `Hash`, then `derive_more`, then feature-gated derives.
 - For error types, only derive `Display` and `Error` from `derive_more` when each is actually needed. Not all displayable types are errors.
 - Minimize `unwrap()` in non-test code. Use proper error handling instead.
 - Prefer `#[cfg_attr(..., ignore = "reason")]` over `#[cfg(...)]` when skipping tests. Use `#[cfg]` on tests only when the code cannot compile under the condition, such as when it references types or functions that do not exist on other platforms.

AGENTS.md

@@ -12,7 +12,6 @@ Read and follow the CONTRIBUTING.md file in this repository for all code style c
 - Use descriptive names for variables and closure parameters. Single letters are permitted only in these cases: (1) conventional names like `n` for count or `f` for formatter; (2) comparison closures like `|a, b|`; (3) trivial single-expression closures; (4) fold accumulators; (5) index variables `i`/`j`/`k` in short closures or index-based loops; and (6) test fixtures with identical roles. Single letters are never permitted in multi-line functions or closures.
 - Use `pipe-trait` to chain through unary functions such as constructors, `Some`, `Ok`, and free functions. Use it to flatten nested calls and to continue method chains. Do not use it for simple standalone calls; prefer `foo(value)` over `value.pipe(foo)`.
 - Prefer `where` clauses when a type has multiple trait bounds.
-- Derive order: standard traits, then comparison traits, then `Hash`, then `derive_more`, then feature-gated derives.
 - For error types, only derive `Display` and `Error` from `derive_more` when each is actually needed. Not all displayable types are errors.
 - Minimize `unwrap()` in non-test code. Use proper error handling instead.
 - Prefer `#[cfg_attr(..., ignore = "reason")]` over `#[cfg(...)]` when skipping tests. Use `#[cfg]` on tests only when the code cannot compile under the condition, such as when it references types or functions that do not exist on other platforms.

CLAUDE.md

@@ -12,7 +12,6 @@ Read and follow the CONTRIBUTING.md file in this repository for all code style c
 - Use descriptive names for variables and closure parameters. Single letters are permitted only in these cases: (1) conventional names like `n` for count or `f` for formatter; (2) comparison closures like `|a, b|`; (3) trivial single-expression closures; (4) fold accumulators; (5) index variables `i`/`j`/`k` in short closures or index-based loops; and (6) test fixtures with identical roles. Single letters are never permitted in multi-line functions or closures.
 - Use `pipe-trait` to chain through unary functions such as constructors, `Some`, `Ok`, and free functions. Use it to flatten nested calls and to continue method chains. Do not use it for simple standalone calls; prefer `foo(value)` over `value.pipe(foo)`.
 - Prefer `where` clauses when a type has multiple trait bounds.
-- Derive order: standard traits, then comparison traits, then `Hash`, then `derive_more`, then feature-gated derives.
 - For error types, only derive `Display` and `Error` from `derive_more` when each is actually needed. Not all displayable types are errors.
 - Minimize `unwrap()` in non-test code. Use proper error handling instead.
 - Prefer `#[cfg_attr(..., ignore = "reason")]` over `#[cfg(...)]` when skipping tests. Use `#[cfg]` on tests only when the code cannot compile under the condition, such as when it references types or functions that do not exist on other platforms.

CONTRIBUTING.md

@@ -71,16 +71,12 @@ pub use event::Event;
 
 ### Derive Macro Ordering
 
-When deriving multiple traits, use this order and split across multiple `#[derive(...)]` lines for readability:
+The order of trait names within each `#[derive(...)]` attribute is enforced automatically by the `perfectionist::derive_ordering` rule, configured for the `prefix_then_alphabetical` style. The configured `prefix` in `dylint.toml` lists the trait families in their project-preferred order: `Debug`, formatting / error derives (`Display`, `Error`), defaults (`Default`, `SmartDefault`), `Clone` / `Copy`, comparison and `Hash`, reference wrappers (`AsRef`, `AsMut`, `Deref`, `DerefMut`), conversions (`From`, `Into`, `TryFrom`, `TryInto`, `FromStr`), iteration, arithmetic operator pairs and folds, and integer-format derives. Any trait that is not in the `prefix` (project-specific derives such as `Setters` and `Parser`) falls in ASCII-case-insensitive alphabetical order after the prefix entries.
 
-1. **Standard traits:** `Debug`, `Default`, `Clone`, `Copy`
-2. **Comparison traits:** `PartialEq`, `Eq`, `PartialOrd`, `Ord`
-3. **Hash**
-4. **`derive_more` traits:** `Display`, `From`, `Into`, `Add`, `AddAssign`, etc.
-5. **Feature-gated derives** on a separate `#[cfg_attr(...)]` line
+The remaining conventions are not enforced by the rule and must be applied by hand. When a type derives many traits, split them across multiple `#[derive(...)]` lines for readability, and place feature-gated derives on a separate `#[cfg_attr(...)]` line.
 
 ```rust
-#[derive(Debug, Default, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+#[derive(Debug, Display, Default, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
 #[derive(From, Into, Add, AddAssign, Sub, SubAssign, Sum)]
 #[cfg_attr(feature = "json", derive(Deserialize, Serialize))]
 pub struct Bytes(u64);
@@ -92,11 +88,11 @@ Use **descriptive names** for type parameters, not single letters:
 
 - `Size`, `Name`, `SizeGetter`, `HardlinksRecorder`, `Report`
 
-Single-letter generics are acceptable only in very short, self-contained trait impls.
+Single-letter generics are acceptable only in very short, self-contained trait impls. Enforced by `perfectionist::single_letter_generic`; the threshold for "very short" is the rule's `short_impl_max_lines` knob in `dylint.toml`.
 
 ### Variable and Closure Parameter Naming
 
-Use **descriptive names** for variables and closure parameters by default. Single-letter names are permitted only in the specific cases listed below.
+Use **descriptive names** for variables and closure parameters by default. Single-letter names are permitted only in the specific cases listed below. Enforced by `perfectionist::single_letter_let_binding`, `perfectionist::single_letter_function_param`, and `perfectionist::single_letter_closure_param`; the per-rule `allowed_idents` and `extra_trivial_callback_methods` knobs in `dylint.toml` reflect the exceptions documented here.
 
 #### When single-letter names are allowed
 

Cargo.toml

@@ -88,6 +88,9 @@ terminal_size = "0.4.4"
 text-block-macros = "0.2.0"
 zero-copy-pads = "0.2.0"
 
+[lints.rust]
+unexpected_cfgs = { level = "warn", check-cfg = ['cfg(dylint_lib, values("perfectionist"))'] }
+
 [dev-dependencies]
 build-fs-tree = "0.8.1"
 command-extra = "1.0.0"

dylint.toml

@@ -1,4 +1,26 @@
 [workspace.metadata.dylint]
 libraries = [
-    { git = "https://github.com/KSXGitHub/perfectionist", tag = "0.0.0-rc.7" },
+    { git = "https://github.com/KSXGitHub/perfectionist", tag = "0.0.0-rc.14" },
 ]
+
+["perfectionist::derive_ordering"]
+style = "prefix_then_alphabetical"
+prefix = [
+    "Debug", "Display", "Error",
+    "Default", "SmartDefault",
+    "Clone", "Copy",
+    "PartialEq", "Eq", "PartialOrd", "Ord",
+    "Hash",
+    "AsRef", "AsMut", "Deref", "DerefMut",
+    "From", "Into", "TryFrom", "TryInto", "FromStr",
+    "IntoIterator",
+    "Add", "AddAssign", "Sub", "SubAssign", "Mul", "MulAssign", "Div", "DivAssign",
+    "Sum", "Product",
+    "LowerHex", "UpperHex", "Octal",
+]
+
+["perfectionist::macro_argument_binding"]
+deny_extra = ["debug_assert_op", "debug_assert_op_expr"]
+
+["perfectionist::single_letter_closure_param"]
+extra_trivial_callback_methods = ["sort_reflection_by"]

src/app/overlapping_arguments.rs

@@ -14,7 +14,7 @@ pub trait Api {
     type RealPathError;
     fn canonicalize(path: &Self::Argument) -> Result<Self::RealPath, Self::RealPathError>;
     fn is_real_dir(path: &Self::Argument) -> bool;
-    fn starts_with(a: &Self::RealPath, b: &Self::RealPath) -> bool;
+    fn starts_with(path: &Self::RealPath, prefix: &Self::RealPath) -> bool;
 }
 
 /// Implementation of [`Api`] that interacts with the real system.
@@ -36,8 +36,8 @@ impl Api for RealApi {
     }
 
     #[inline]
-    fn starts_with(a: &Self::RealPath, b: &Self::RealPath) -> bool {
-        a.starts_with(b)
+    fn starts_with(path: &Self::RealPath, prefix: &Self::RealPath) -> bool {
+        path.starts_with(prefix)
     }
 }
 

src/app/overlapping_arguments/test_remove_overlapping_paths.rs

@@ -64,8 +64,8 @@ impl Api for MockedApi {
             .all(|(link, _)| PathBuf::from(link).normalize() != path)
     }
 
-    fn starts_with(a: &Self::RealPath, b: &Self::RealPath) -> bool {
-        a.starts_with(b)
+    fn starts_with(path: &Self::RealPath, prefix: &Self::RealPath) -> bool {
+        path.starts_with(prefix)
     }
 }
 

src/args.rs

@@ -17,7 +17,7 @@ use terminal_size::{Width, terminal_size};
 use text_block_macros::text_block;
 
 /// The CLI arguments.
-#[derive(Debug, SmartDefault, Setters, Clone, Parser)]
+#[derive(Debug, SmartDefault, Clone, Parser, Setters)]
 #[clap(
     name = "pdu",
 

src/args/depth.rs

@@ -7,7 +7,7 @@ use std::{
 const INFINITE: &str = "inf";
 
 /// Maximum depth of the tree.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Display)]
+#[derive(Debug, Display, Clone, Copy, PartialEq, Eq)]
 pub enum Depth {
     #[display("{INFINITE}")]
     Infinite,
@@ -25,7 +25,7 @@ impl Depth {
 }
 
 /// Error that occurs when parsing a string as [`Depth`].
-#[derive(Debug, Display, Clone, PartialEq, Eq, Error)]
+#[derive(Debug, Display, Error, Clone, PartialEq, Eq)]
 #[non_exhaustive]
 pub enum FromStrError {
     #[display("Value is neither {INFINITE:?} nor a positive integer: {_0}")]