fix: build coloring map before renaming synthetic root to "(total)"

Move the coloring map construction to before the "" → "(total)" rename
so that file_color() receives real filesystem paths. After renaming,
rekey the map to replace "" with "(total)" so keys match the
visualizer's ancestor chain.

Switch coloring map keys from borrowed Vec<&OsStr> to owned
Vec<OsString> to avoid lifetime conflicts when mutating the data tree
root name after the map is built.

Also fix unused-mut warning in color_always_multiple_args test.

https://claude.ai/code/session_01YKNARZMxcXeYyGZhHMurHA

Author: claude

src/app/sub.rs

@@ -17,7 +17,7 @@ use pipe_trait::Pipe;
 use serde::Serialize;
 use std::{
     collections::HashMap,
-    ffi::OsStr,
+    ffi::{OsStr, OsString},
     io::stdout,
     iter::once,
     path::{Path, PathBuf},
@@ -133,7 +133,7 @@ where
         }
 
         let min_ratio: f32 = min_ratio.into();
-        let (data_tree, deduplication_record) = {
+        let (mut data_tree, deduplication_record) = {
             let mut data_tree = data_tree;
             if min_ratio > 0.0 {
                 data_tree.par_cull_insignificant_data(min_ratio);
@@ -144,11 +144,41 @@ where
             let deduplication_record = hardlinks_handler.deduplicate(&mut data_tree);
             if !only_one_arg {
                 assert_eq!(data_tree.name().as_os_str().to_str(), Some(""));
-                *data_tree.name_mut() = OsStringDisplay::os_string_from("(total)");
             }
             (data_tree, deduplication_record)
         };
 
+        // Build the coloring map while the multi-arg root is still "" (a valid path prefix)
+        // so that file_color receives real filesystem paths.
+        let mut leaf_color_map: Option<HashMap<Vec<OsString>, Color>> = color.as_ref().map(|_| {
+            let mut map = HashMap::new();
+            build_coloring_map(&data_tree, &mut Vec::new(), &mut map);
+            map
+        });
+
+        // Rename the synthetic root and rekey the coloring map to match.
+        if !only_one_arg {
+            *data_tree.name_mut() = OsStringDisplay::os_string_from("(total)");
+            if let Some(map) = &mut leaf_color_map {
+                let total = OsString::from("(total)");
+                let empty = OsString::from("");
+                *map = map
+                    .drain()
+                    .map(|(mut key, color)| {
+                        if key.first() == Some(&empty) {
+                            key[0] = total.clone();
+                        }
+                        (key, color)
+                    })
+                    .collect();
+            }
+        }
+
+        let coloring: Option<Coloring> = color.map(|ls_colors| {
+            let map = leaf_color_map.take().unwrap();
+            Coloring::new(ls_colors, map)
+        });
+
         GLOBAL_STATUS_BOARD.clear_line(0);
 
         if let Some(json_output) = json_output {
@@ -198,24 +228,6 @@ where
                 .or(deduplication_result);
         }
 
-        let coloring: Option<Coloring> = color.map(|ls_colors| {
-            let mut map = HashMap::new();
-            if only_one_arg {
-                build_coloring_map(&data_tree, &mut Vec::new(), &mut Vec::new(), &mut map);
-            } else {
-                // For multi-arg invocations the root is the synthetic "(total)" node.
-                // Include it in the map key (the visualizer's ancestor chain contains it)
-                // but skip it in the filesystem path (it doesn't exist on disk).
-                let root_name = data_tree.name().as_os_str();
-                for child in data_tree.children() {
-                    let mut key_stack = vec![root_name];
-                    let mut fs_stack = Vec::new();
-                    build_coloring_map(child, &mut key_stack, &mut fs_stack, &mut map);
-                }
-            }
-            Coloring::new(ls_colors, map)
-        });
-
         let visualizer = Visualizer {
             data_tree: &data_tree,
             bytes_format,
@@ -294,33 +306,27 @@ where
 
 /// Recursively walk a pruned [`DataTree`] and build a map of path-component vectors to [`Color`] values.
 ///
-/// `key_stack` tracks the ancestor chain used as the HashMap key (must match what the
-/// [`Visualizer`] constructs). `fs_path_stack` tracks the real filesystem path used for
-/// file-type detection. These two stacks diverge when the root is a synthetic node like
-/// `(total)` that has no corresponding directory on disk.
-///
+/// The `path_stack` argument is a reusable buffer of path components representing the current
+/// ancestor chain. Each recursive call pushes the node's name and pops it on return, so no
+/// cloning occurs during traversal — only at leaf insertions.
 /// Leaf nodes (files or childless directories after pruning) are added to the map.
 /// Nodes with children are skipped because the [`Visualizer`] uses the children count to
 /// determine their color at render time.
 fn build_coloring_map<'a>(
     node: &'a DataTree<OsStringDisplay, impl size::Size>,
-    key_stack: &mut Vec<&'a OsStr>,
-    fs_path_stack: &mut Vec<&'a OsStr>,
-    map: &mut HashMap<Vec<&'a OsStr>, Color>,
+    path_stack: &mut Vec<&'a OsStr>,
+    map: &mut HashMap<Vec<OsString>, Color>,
 ) {
-    let name = node.name().as_os_str();
-    key_stack.push(name);
-    fs_path_stack.push(name);
+    path_stack.push(node.name().as_os_str());
     if node.children().is_empty() {
-        let color = file_color(&fs_path_stack.iter().collect::<PathBuf>());
-        map.insert(key_stack.clone(), color);
+        let color = file_color(&path_stack.iter().collect::<PathBuf>());
+        map.insert(path_stack.iter().map(|s| s.to_os_string()).collect(), color);
     } else {
         for child in node.children() {
-            build_coloring_map(child, key_stack, fs_path_stack, map);
+            build_coloring_map(child, path_stack, map);
         }
     }
-    key_stack.pop();
-    fs_path_stack.pop();
+    path_stack.pop();
 }
 
 fn file_color(path: &Path) -> Color {

src/visualizer.rs

@@ -62,7 +62,7 @@ where
     /// Distribution and total number of characters/blocks can be placed in a line.
     pub column_width_distribution: ColumnWidthDistribution,
     /// Optional coloring configuration for colorful output, mapping full node paths to colors.
-    pub coloring: Option<&'a Coloring<'a>>,
+    pub coloring: Option<&'a Coloring>,
 }
 
 mod copy;

src/visualizer/coloring.rs

@@ -1,19 +1,23 @@
 use super::{ChildPosition, TreeHorizontalSlice};
 use crate::ls_colors::LsColors;
 use derive_more::Display;
-use std::{collections::HashMap, ffi::OsStr, fmt};
+use std::{
+    collections::HashMap,
+    ffi::{OsStr, OsString},
+    fmt,
+};
 use zero_copy_pads::Width;
 
 /// Coloring configuration: ANSI prefix strings from the environment and a full-path-to-color map.
 #[derive(Debug)]
-pub struct Coloring<'a> {
+pub struct Coloring {
     ls_colors: LsColors,
-    map: HashMap<Vec<&'a OsStr>, Color>,
+    map: HashMap<Vec<OsString>, Color>,
 }
 
-impl<'a> Coloring<'a> {
+impl Coloring {
     /// Create a new [`Coloring`] from LS_COLORS prefixes and a path-components-to-color map.
-    pub fn new(ls_colors: LsColors, map: HashMap<Vec<&'a OsStr>, Color>) -> Self {
+    pub fn new(ls_colors: LsColors, map: HashMap<Vec<OsString>, Color>) -> Self {
         Coloring { ls_colors, map }
     }
 }
@@ -91,7 +95,7 @@ impl Width for ColoredTreeHorizontalSlice<'_> {
 /// Path components are only constructed when coloring is enabled, avoiding
 /// unnecessary allocation in the common no-color case.
 pub(super) fn maybe_colored_slice<'a, 'b>(
-    coloring: Option<&'b Coloring<'a>>,
+    coloring: Option<&'b Coloring>,
     ancestors: impl Iterator<Item = &'a OsStr>,
     name: &'a OsStr,
     has_children: bool,
@@ -101,7 +105,10 @@ pub(super) fn maybe_colored_slice<'a, 'b>(
         Some(coloring) => coloring,
         None => return MaybeColoredTreeHorizontalSlice::Colorless(slice),
     };
-    let path_components: Vec<&OsStr> = ancestors.chain(std::iter::once(name)).collect();
+    let path_components: Vec<OsString> = ancestors
+        .chain(std::iter::once(name))
+        .map(OsString::from)
+        .collect();
     let color = if has_children {
         Some(Color::Directory)
     } else {

tests/usual_cli.rs

@@ -28,7 +28,7 @@ use parallel_disk_usage::{
     visualizer::{Color, Coloring},
 };
 #[cfg(unix)]
-use std::{collections::HashMap, ffi::OsStr};
+use std::{collections::HashMap, ffi::OsString};
 
 fn stdio(command: Command) -> Command {
     command
@@ -857,9 +857,7 @@ fn color_always() {
     ];
     let leaf_colors = HashMap::from(leaf_colors.map(|(path, color)| {
         (
-            path.split('/')
-                .map(AsRef::<OsStr>::as_ref)
-                .collect::<Vec<_>>(),
+            path.split('/').map(OsString::from).collect::<Vec<_>>(),
             color,
         )
     }));
@@ -913,7 +911,7 @@ fn color_always_multiple_args() {
     };
     eprintln!("ACTUAL:\n{actual}\n");
 
-    let mut data_tree = args
+    let data_tree = args
         .iter()
         .map(|name| {
             let builder = FsTreeBuilder {
@@ -950,9 +948,7 @@ fn color_always_multiple_args() {
     ];
     let leaf_colors = HashMap::from(leaf_colors.map(|(path, color)| {
         (
-            path.split('/')
-                .map(AsRef::<OsStr>::as_ref)
-                .collect::<Vec<_>>(),
+            path.split('/').map(OsString::from).collect::<Vec<_>>(),
             color,
         )
     }));