chore(deps): bump perfectionist to KSXGitHub/perfectionist#52 head

PR 52 (`93cb529`) fixes four of the five `macro_argument_binding`
bug classes filed earlier:

- #415 — `debug_assert_*` trivial-comparison no longer flagged when
  the comparison is over side-effect-free operands. Removed
  function-scope `#[expect]` suppressions in `data_tree::hardlink`,
  `visualizer::methods::bar_table`, and
  `visualizer::methods::initial_table`.
- #416 — `name = value` / `name += value` DSL matchers no longer
  flagged. Removed the function-scope suppression on
  `reporter::progress_and_error_reporter::report`. The narrower
  `->` / `in` separators used by `tests::bytes_format::test_case!`
  are not yet covered, so its crate-root suppression remains, with
  the reason updated to point at the partial fix.
- #417 — unit literal `()` is now trivial. Removed the
  function-scope suppression on `app::App::run`.
- #418 — bare operator tokens (`==`, `>`) used as positional
  separators in `debug_assert_op_expr!` are no longer flagged.

The lone residual flag in `visualizer::methods::tree_table`
(`debug_assert_op_expr!(intermediate_table.len(), ==, ...)`) is
correct rule behaviour: the rule cannot prove `Vec::len` is pure.
Replaced the broad suppression with a narrower one citing
`Vec::len`'s `O(1)`-pure-read contract.

PR 43, folded into PR 52's branch, splits `single_letter_names`
into separate per-rule config keys. Migrate the
`comparison_methods` allowlist from
`[perfectionist::single_letter_names]` to the new
`[perfectionist::single_letter_closure_param]` section so the
project-specific `sort_reflection_by` / `into_sorted_by` helpers
remain exempt from the closure-parameter check.

https://claude.ai/code/session_01CoRidYHvni9nKNgxMPXmfQ

Author: claude

dylint.toml

@@ -1,6 +1,6 @@
 [workspace.metadata.dylint]
 libraries = [
-    { git = "https://github.com/KSXGitHub/perfectionist", tag = "0.0.0-rc.9" },
+    { git = "https://github.com/KSXGitHub/perfectionist", rev = "93cb529c15ae9e0ac8ef093efee58219b8d68cb7" },
 ]
 
 ["perfectionist::derive_ordering"]
@@ -38,7 +38,7 @@ prefix = [
     "LowerHex", "UpperHex", "Octal",
 ]
 
-["perfectionist::single_letter_names"]
+["perfectionist::single_letter_closure_param"]
 # Treat project-specific and third-party comparison-style helpers as if
 # they were standard `sort_by`-shaped methods, so the idiomatic
 # `|a, b| a.field.cmp(&b.field)` closure does not trip the rule. The

src/app.rs

@@ -39,13 +39,6 @@ impl App {
     }
 
     /// Run the application.
-    #[cfg_attr(
-        dylint_lib = "perfectionist",
-        expect(
-            perfectionist::macro_argument_binding,
-            reason = "the unit literal `()` is the canonical trivial value, but the rule's trivial-expression grammar does not yet accept parenthesised forms; see #417",
-        )
-    )]
     pub fn run(mut self) -> Result<(), RuntimeError> {
         // DYNAMIC DISPATCH POLICY:
         //

src/data_tree/hardlink.rs

@@ -12,13 +12,6 @@ where
 {
     /// Reduce the size of the directories that have hardlinks.
     #[cfg_attr(not(unix), expect(unused))]
-    #[cfg_attr(
-        dylint_lib = "perfectionist",
-        expect(
-            perfectionist::macro_argument_binding,
-            reason = "binding a `debug_assert_op!` argument to a `let` forces it to run in release builds, which defeats the entire point of `debug_assert_*`; see #415",
-        )
-    )]
     pub(crate) fn par_deduplicate_hardlinks(&mut self, hardlink_info: &[(Size, Vec<&Path>)]) {
         if hardlink_info.is_empty() {
             return;

src/reporter/progress_and_error_reporter.rs

@@ -79,13 +79,6 @@ where
     ReportError: Fn(ErrorReport) + Sync,
     u64: Into<Size>,
 {
-    #[cfg_attr(
-        dylint_lib = "perfectionist",
-        expect(
-            perfectionist::macro_argument_binding,
-            reason = "the `bump!` macro's `($field:ident += $delta:expr)` matcher uses structural assignment syntax rather than a single expression, so binding the argument to a `let` is not even syntactically possible; see #416",
-        )
-    )]
     fn report(&self, event: Event<Size>) {
         use Event::*;
         let ProgressAndErrorReporter {

src/visualizer/methods/bar_table.rs

@@ -12,13 +12,6 @@ pub(super) struct BarRow<Name, NodeData> {
     pub(super) proportion_bar: ProportionBar,
 }
 
-#[cfg_attr(
-    dylint_lib = "perfectionist",
-    expect(
-        perfectionist::macro_argument_binding,
-        reason = "the flagged sites are all `debug_assert_op!` / `debug_assert_op_expr!` calls on side-effect-free locals; binding to a `let` would defeat the debug-only contract (see #415), and the rule also miscategorises bare operator tokens like `==` as expressions (see #418)",
-    )
-)]
 pub(super) fn render_bars<'a, Name, Size>(
     tree_table: TreeTable<&'a Name, Size>,
     total: u64,

src/visualizer/methods/initial_table.rs

@@ -37,13 +37,6 @@ impl InitialColumnWidth {
 pub(super) type InitialTable<Name, NodeData> =
     Table<InitialRow<Name, NodeData>, InitialColumnWidth>;
 
-#[cfg_attr(
-    dylint_lib = "perfectionist",
-    expect(
-        perfectionist::macro_argument_binding,
-        reason = "the flagged sites are `debug_assert_op!` calls on side-effect-free locals; binding to a `let` would defeat the debug-only contract. See #415",
-    )
-)]
 pub(super) fn render_initial<Name, Size>(
     visualizer: Visualizer<'_, Name, Size>,
 ) -> InitialTable<&'_ Name, Size>

src/visualizer/methods/tree_table.rs

@@ -45,7 +45,7 @@ pub(super) type TreeTable<Name, NodeData> = Table<TreeRow<Name, NodeData>, TreeC
     dylint_lib = "perfectionist",
     expect(
         perfectionist::macro_argument_binding,
-        reason = "the flagged sites are `debug_assert_op!` / `debug_assert_op_expr!` calls; binding to a `let` would defeat the debug-only contract (see #415), and the rule miscategorises bare operator tokens like `==` and `>` as expressions (see #418)",
+        reason = "`Vec::len` is a pure `O(1)` read; the `debug_assert_op_expr!` invocation below intentionally keeps the call inside the assertion so it runs only in debug builds, and binding it to a `let` would lift the call into release builds for no benefit",
     )
 )]
 pub(super) fn render_tree<'a, Name, Size>(

tests/bytes_format.rs

@@ -4,7 +4,7 @@
     dylint_lib = "perfectionist",
     expect(
         perfectionist::macro_argument_binding,
-        reason = "the `test_case!` macro uses a `name -> value in system == expected` DSL whose separators (`->`, `in`, `==`) are matcher tokens, not expression operators; binding the argument to a `let` is not even syntactically applicable. See #416. The crate-root scope is forced by an upstream late-pass anchoring quirk: violations in module-level item-position macro expansions resolve to the crate root, where finer-scoped `#[expect]` cannot reach them.",
+        reason = "the `test_case!` macro uses a `name -> value in system == expected` DSL whose `->` and `in` separators are not yet recognised by the rule's non-expression marker list (PR #52 added `=`, `+=`, and bare operators but not these). See #416. The crate-root scope is forced by an upstream late-pass anchoring quirk: violations in module-level item-position macro expansions resolve to the crate root, where finer-scoped `#[expect]` cannot reach them (#419).",
     )
 )]