chore(deps): upgrade perfectionist to 0.0.0-rc.9

The new rule `macro_argument_binding` flags 25 sites across the
codebase. Investigation showed every single one to be a false
positive belonging to one of five upstream bug classes, filed
as #415, #416, #417, #418, and #419. None of the suggested
"bind to a `let` first" fixes are correct here:

- The 13 `debug_assert_op!` / `debug_assert_op_expr!` sites
  would have their arguments forced to run in release builds
  (#415), defeating the entire point of `debug_assert_*`.
- The `make_const!` and `bump!` matchers (#416) use definition
  / compound-assignment shapes that have no `let`-binding form.
- `app::App::run` passes the unit literal `()`, which the
  rule's grammar fails to recognise as trivial (#417).
- `debug_assert_op_expr!`'s middle operator argument (`==`,
  `>`) is a bare token, not an expression at all (#418).
- The late pass anchors item-position macro violations at the
  crate root (#419), which is why module-scope `#[expect]`
  cannot suppress them and `proportion_bar.rs`'s `make_const!`
  macro had to be expanded into five `pub const` lines by hand.

Apply `#[cfg_attr(dylint_lib = "perfectionist", expect(...))]`
at the smallest scope each false positive permits (function
scope where the macro call is statement-position, crate root
in `tests/bytes_format.rs` where the call is item-position).
Rewrite the `link!` / `symlink!` macros in `tests/_utils.rs`
as closures so the test-utility module needs no suppression.

https://claude.ai/code/session_01CoRidYHvni9nKNgxMPXmfQ

Author: claude

dylint.toml

@@ -1,6 +1,6 @@
 [workspace.metadata.dylint]
 libraries = [
-    { git = "https://github.com/KSXGitHub/perfectionist", rev = "a21a146eff0ff5b61571160d287fec100879046d" },
+    { git = "https://github.com/KSXGitHub/perfectionist", tag = "0.0.0-rc.9" },
 ]
 
 ["perfectionist::single_letter_names"]

src/app.rs

@@ -39,6 +39,13 @@ 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,6 +12,13 @@ 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,6 +79,13 @@ 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,6 +12,13 @@ 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,6 +37,13 @@ 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

@@ -41,6 +41,13 @@ impl TreeColumnWidth {
 
 pub(super) type TreeTable<Name, NodeData> = Table<TreeRow<Name, NodeData>, TreeColumnWidth>;
 
+#[cfg_attr(
+    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)",
+    )
+)]
 pub(super) fn render_tree<'a, Name, Size>(
     visualizer: Visualizer<'a, Name, Size>,
     initial_table: InitialTable<&'a Name, Size>,

src/visualizer/proportion_bar.rs

@@ -7,17 +7,11 @@ use std::fmt::{Display, Error, Formatter};
 #[derive(Debug, Clone, Copy, PartialEq, Eq, AsRef, Deref, Display, Into)]
 pub struct ProportionBarBlock(char);
 
-macro_rules! make_const {
-    ($name:ident = $content:literal) => {
-        pub const $name: ProportionBarBlock = ProportionBarBlock($content);
-    };
-}
-
-make_const!(LEVEL0_BLOCK = '█');
-make_const!(LEVEL1_BLOCK = '▓');
-make_const!(LEVEL2_BLOCK = '▒');
-make_const!(LEVEL3_BLOCK = '░');
-make_const!(LEVEL4_BLOCK = ' ');
+pub const LEVEL0_BLOCK: ProportionBarBlock = ProportionBarBlock('█');
+pub const LEVEL1_BLOCK: ProportionBarBlock = ProportionBarBlock('▓');
+pub const LEVEL2_BLOCK: ProportionBarBlock = ProportionBarBlock('▒');
+pub const LEVEL3_BLOCK: ProportionBarBlock = ProportionBarBlock('░');
+pub const LEVEL4_BLOCK: ProportionBarBlock = ProportionBarBlock(' ');
 
 /// Proportion bar.
 #[derive(Debug, Clone, Copy, PartialEq, Eq, From, Into)]

tests/_utils.rs

@@ -125,22 +125,36 @@ impl SampleWorkspace {
         .build(&temp)
         .expect("build the filesystem tree for the sample workspace");
 
-        macro_rules! link {
-            ($original:literal -> $link:literal) => {{
-                let original = $original;
-                let link = $link;
-                if let Err(error) = hard_link(temp.join(original), temp.join(link)) {
-                    panic!("Failed to link {original} to {link}: {error}");
-                }
-            }};
-        }
+        let link = |original: &str, link: &str| {
+            if let Err(error) = hard_link(temp.join(original), temp.join(link)) {
+                panic!("Failed to link {original} to {link}: {error}");
+            }
+        };
 
-        link!("main/sources/one-internal-hardlink.txt" -> "main/internal-hardlinks/link-0.txt");
-        link!("main/sources/two-internal-hardlinks.txt" -> "main/internal-hardlinks/link-1a.txt");
-        link!("main/sources/two-internal-hardlinks.txt" -> "main/internal-hardlinks/link-1b.txt");
-        link!("main/sources/one-external-hardlink.txt" -> "external-hardlinks/link-2.txt");
-        link!("main/sources/one-internal-one-external-hardlinks.txt" -> "main/internal-hardlinks/link-3a.txt");
-        link!("main/sources/one-internal-one-external-hardlinks.txt" -> "external-hardlinks/link-3b.txt");
+        link(
+            "main/sources/one-internal-hardlink.txt",
+            "main/internal-hardlinks/link-0.txt",
+        );
+        link(
+            "main/sources/two-internal-hardlinks.txt",
+            "main/internal-hardlinks/link-1a.txt",
+        );
+        link(
+            "main/sources/two-internal-hardlinks.txt",
+            "main/internal-hardlinks/link-1b.txt",
+        );
+        link(
+            "main/sources/one-external-hardlink.txt",
+            "external-hardlinks/link-2.txt",
+        );
+        link(
+            "main/sources/one-internal-one-external-hardlinks.txt",
+            "main/internal-hardlinks/link-3a.txt",
+        );
+        link(
+            "main/sources/one-internal-one-external-hardlinks.txt",
+            "external-hardlinks/link-3b.txt",
+        );
 
         SampleWorkspace(temp)
     }
@@ -149,21 +163,17 @@ impl SampleWorkspace {
         use std::os::unix::fs::symlink;
         let workspace = SampleWorkspace::simple_tree_with_some_hardlinks(sizes);
 
-        macro_rules! symlink {
-            ($link_name:literal -> $target:literal) => {
-                let link_name = $link_name;
-                let target = $target;
-                if let Err(error) = symlink(target, workspace.join(link_name)) {
-                    panic!("Failed create symbolic link {link_name} pointing to {target}: {error}");
-                }
-            };
-        }
+        let link = |link_name: &str, target: &str| {
+            if let Err(error) = symlink(target, workspace.join(link_name)) {
+                panic!("Failed create symbolic link {link_name} pointing to {target}: {error}");
+            }
+        };
 
-        symlink!("workspace-itself" -> ".");
-        symlink!("main/main-itself" -> ".");
-        symlink!("main/parent-of-main" -> "..");
-        symlink!("main-mirror" -> "./main");
-        symlink!("sources-mirror" -> "./main/sources");
+        link("workspace-itself", ".");
+        link("main/main-itself", ".");
+        link("main/parent-of-main", "..");
+        link("main-mirror", "./main");
+        link("sources-mirror", "./main/sources");
 
         workspace
     }

tests/bytes_format.rs

@@ -1,3 +1,13 @@
+#![cfg_attr(dylint_lib = "perfectionist", feature(register_tool))]
+#![cfg_attr(dylint_lib = "perfectionist", register_tool(perfectionist))]
+#![cfg_attr(
+    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.",
+    )
+)]
+
 use parallel_disk_usage::bytes_format::BytesFormat;
 use pretty_assertions::assert_eq;