lint!: enable perfectionist::derive_ordering

Configure the rule for `prefix_then_alphabetical` with an explicit
`prefix` that encodes the project's preferred derive families in
order: standard, comparison, `Hash`, formatting / error,
conversions, reference wrappers, iteration, arithmetic operator
pairs and folds, and integer-format derives. Anything not in the
prefix (`Setters`, `SmartDefault`, `Parser`, …) falls in ASCII-
case-insensitive alphabetical order after, matching the existing
convention.

Reorder 18 derive lists across the codebase to satisfy the rule.
Every case had derive-more-style traits mixed into the standard-
trait block, contradicting the convention CONTRIBUTING.md already
documents; the rule's suggestions match that documented intent.

Document the rule in `CONTRIBUTING.md`'s derive-ordering section,
and drop the now-redundant within-line ordering bullet from the
shared AI-instructions template (the rule enforces it). The
line-splitting convention (separate `#[cfg_attr(...)]` line for
feature-gated derives) is not enforced by the rule and stays in
the contributing guide as a manual style preference.

https://claude.ai/code/session_01CoRidYHvni9nKNgxMPXmfQ

Author: claude

.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,13 +71,9 @@ 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: standard traits, then comparison traits, then `Hash`, then formatting / error derives, then conversions, then reference wrappers, then iteration, then arithmetic operator pairs and folds, then integer-format derives. Any trait that is not in the `prefix` (project-specific derives such as `Setters`, `SmartDefault`, 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)]

dylint.toml

@@ -3,6 +3,41 @@ libraries = [
     { git = "https://github.com/KSXGitHub/perfectionist", tag = "0.0.0-rc.9" },
 ]
 
+["perfectionist::derive_ordering"]
+# Match the convention documented in `CONTRIBUTING.md`. The `prefix`
+# extends the rule's default with the derive-more-style families this
+# project uses, in the project-preferred logical order: formatting
+# (`Display`, `Error`), conversions (`From`, `Into`, …), reference
+# wrappers (`AsRef`, `AsMut`, `Deref`, `DerefMut`), iteration
+# (`IntoIterator`), arithmetic operator pairs (`Add` / `AddAssign`,
+# `Sub` / `SubAssign`, …), and integer-format derives (`LowerHex`,
+# `UpperHex`, `Octal`). Anything not listed here (project-specific
+# `Setters`, `SmartDefault`, `Parser`, etc.) falls alphabetically
+# after the prefix, which matches the existing convention.
+style = "prefix_then_alphabetical"
+prefix = [
+    # Standard traits.
+    "Debug", "Default", "Clone", "Copy",
+    # Comparison traits.
+    "PartialEq", "Eq", "PartialOrd", "Ord",
+    # Hash.
+    "Hash",
+    # Formatting / error.
+    "Display", "Error",
+    # Conversions.
+    "From", "Into", "TryFrom", "TryInto", "FromStr",
+    # Reference wrappers.
+    "AsRef", "AsMut", "Deref", "DerefMut",
+    # Iteration.
+    "IntoIterator",
+    # Arithmetic operator pairs.
+    "Add", "AddAssign", "Sub", "SubAssign", "Mul", "MulAssign", "Div", "DivAssign",
+    # Folds.
+    "Sum", "Product",
+    # Integer-format derives.
+    "LowerHex", "UpperHex", "Octal",
+]
+
 ["perfectionist::single_letter_names"]
 # Treat project-specific and third-party comparison-style helpers as if
 # they were standard `sort_by`-shaped methods, so the idiomatic

src/args.rs

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

src/args/depth.rs

@@ -25,7 +25,7 @@ impl Depth {
 }
 
 /// Error that occurs when parsing a string as [`Depth`].
-#[derive(Debug, Display, Clone, PartialEq, Eq, Error)]
+#[derive(Debug, Clone, PartialEq, Eq, Display, Error)]
 #[non_exhaustive]
 pub enum FromStrError {
     #[display("Value is neither {INFINITE:?} nor a positive integer: {_0}")]

src/args/fraction.rs

@@ -6,11 +6,11 @@ use std::{
 };
 
 /// Floating-point value that is greater than or equal to 0 and less than 1.
-#[derive(Debug, Default, Clone, Copy, PartialEq, PartialOrd, AsRef, Deref, Display, Into)]
+#[derive(Debug, Default, Clone, Copy, PartialEq, PartialOrd, Display, Into, AsRef, Deref)]
 pub struct Fraction(f32);
 
 /// Error that occurs when calling [`Fraction::new`].
-#[derive(Debug, Display, Clone, Copy, PartialEq, Eq, Error)]
+#[derive(Debug, Clone, Copy, PartialEq, Eq, Display, Error)]
 #[non_exhaustive]
 pub enum ConversionError {
     /// Provided value is greater than or equal to 1.
@@ -43,7 +43,7 @@ impl TryFrom<f32> for Fraction {
 }
 
 /// Error that occurs when parsing a string as [`Fraction`].
-#[derive(Debug, Display, Clone, PartialEq, Eq, Error)]
+#[derive(Debug, Clone, PartialEq, Eq, Display, Error)]
 #[non_exhaustive]
 pub enum FromStrError {
     ParseFloatError(ParseFloatError),

src/args/threads.rs

@@ -19,7 +19,7 @@ pub enum Threads {
 }
 
 /// Error that occurs when parsing a string as [`Threads`].
-#[derive(Debug, Display, Clone, PartialEq, Eq, Error)]
+#[derive(Debug, Clone, PartialEq, Eq, Display, Error)]
 #[non_exhaustive]
 pub enum FromStrError {
     #[display("Value is neither {AUTO:?}, {MAX:?}, nor a number: {_0}")]

src/bytes_format/output.rs

@@ -2,7 +2,7 @@ use super::ParsedValue;
 use derive_more::Display;
 
 /// The [`DisplayOutput`](crate::size::Size::DisplayOutput) type of [`Bytes`](crate::size::Bytes).
-#[derive(Debug, Display, Clone, Copy)]
+#[derive(Debug, Clone, Copy, Display)]
 pub enum Output {
     /// Display the value as-is.
     PlainNumber(u64),