fix(symbols): rustfmt + clippy + dylint allowlist for #424

CI on PR #424 surfaced three style-gate failures that are easy to
miss locally because the relevant tools each guard a different
sub-policy:

- `manual_pattern_char_comparison` / `manual_saturating_arithmetic`
  clippy lints — convert two `.rsplit(|c| c == '/' || c == '\')`
  closures to `.rsplit(['/', '\'])` and the `checked_add(...)
  .unwrap_or(u64::MAX)` overflow guard to `saturating_add(...)`.
  Same numerical behavior; CI's `-D warnings` posture rejected the
  longhand forms.
- `cargo fmt` diff: minor formatting drift in the new
  `symbol_analysis.rs` test bodies that local `cargo fmt` had not
  applied at commit time.
- Dylint `ban_raw_subprocess` rule: the c++filt-demangling driver in
  `crates/fbuild-build/src/symbol_analyzer.rs` spawns
  `std::process::Command` directly because the captured `run_command`
  helper is stdin-Null only. The pipe-buffer-deadlock workaround
  (separate writer thread + `wait_with_output`) requires raw spawn,
  so add the file to `dylints/ban_raw_subprocess/src/allowlist.txt`
  with the same documented-rationale shape used for the existing
  allowlist entries.

No behavior change; tests still 11/11 green
(9 in fbuild-core + 2 in fbuild-build).

Author: zackees

crates/fbuild-build/src/symbol_analyzer.rs

@@ -87,9 +87,10 @@ pub fn demangle_batch(mangled: &[String], cppfilt_path: &Path) -> Result<Vec<Str
 
     // Move stdin into a writer thread so stdout draining can happen
     // concurrently in the main thread (avoids the pipe-buffer deadlock).
-    let stdin_handle = child.stdin.take().ok_or_else(|| {
-        FbuildError::BuildFailed("c++filt stdin pipe unavailable".to_string())
-    })?;
+    let stdin_handle = child
+        .stdin
+        .take()
+        .ok_or_else(|| FbuildError::BuildFailed("c++filt stdin pipe unavailable".to_string()))?;
     let writer = std::thread::spawn(move || -> std::io::Result<()> {
         let mut stdin = stdin_handle;
         stdin.write_all(stdin_data.as_bytes())?;
@@ -194,7 +195,10 @@ pub fn analyze_elf(cfg: AnalyzeConfig<'_>) -> Result<FineGrainedSymbolMap> {
 /// archive + object + section attribution and demangled names.
 pub fn format_text_report(map: &FineGrainedSymbolMap, top_n: usize) -> String {
     let mut lines = Vec::new();
-    lines.push(format!("=== Fine-grained symbol analysis: {} ===", map.elf_path));
+    lines.push(format!(
+        "=== Fine-grained symbol analysis: {} ===",
+        map.elf_path
+    ));
     if let Some(ref m) = map.map_path {
         lines.push(format!("Map file: {m}"));
     }
@@ -225,7 +229,10 @@ pub fn format_text_report(map: &FineGrainedSymbolMap, top_n: usize) -> String {
     ) {
         let mut syms: Vec<_> = map.symbols.iter().filter(|s| s.region == region).collect();
         syms.sort_by(|a, b| b.size.cmp(&a.size));
-        lines.push(format!("--- Top {} {title} symbols ---", top_n.min(syms.len())));
+        lines.push(format!(
+            "--- Top {} {title} symbols ---",
+            top_n.min(syms.len())
+        ));
         lines.push(format!(
             "{:>8}  {:<24}  {:<28}  {:<14}  symbol",
             "BYTES", "ARCHIVE", "OBJECT", "SECTION"
@@ -259,7 +266,13 @@ pub fn format_text_report(map: &FineGrainedSymbolMap, top_n: usize) -> String {
         top_n,
         "FLASH",
     );
-    emit_region_block(&mut lines, map, fbuild_core::MemoryRegion::Ram, top_n, "RAM");
+    emit_region_block(
+        &mut lines,
+        map,
+        fbuild_core::MemoryRegion::Ram,
+        top_n,
+        "RAM",
+    );
 
     // Per-archive roll-ups (flash only — biggest leverage for bloat).
     let mut by_archive: std::collections::BTreeMap<String, u64> = std::collections::BTreeMap::new();
@@ -302,7 +315,9 @@ mod tests {
         let nm = PathBuf::from("/tools/xtensa-esp32s3-elf-nm.exe");
         let cppfilt = derive_cppfilt_path(&nm);
         assert!(
-            cppfilt.to_string_lossy().ends_with("xtensa-esp32s3-elf-c++filt.exe"),
+            cppfilt
+                .to_string_lossy()
+                .ends_with("xtensa-esp32s3-elf-c++filt.exe"),
             "got {}",
             cppfilt.display()
         );

crates/fbuild-cli/src/cli/symbols_cmd.rs

@@ -47,7 +47,9 @@ pub fn run_symbols(
         }
     });
 
-    let map_path_owned = map.map(PathBuf::from).or_else(|| default_map_path(&elf_path));
+    let map_path_owned = map
+        .map(PathBuf::from)
+        .or_else(|| default_map_path(&elf_path));
     let map_path_ref: Option<&Path> = map_path_owned.as_deref();
 
     let cfg = AnalyzeConfig {
@@ -85,8 +87,7 @@ pub fn run_symbols(
 /// Locate `nm` on PATH. The user can always override with `--nm`.
 fn find_nm_on_path() -> Result<PathBuf> {
     let exe_name = if cfg!(windows) { "nm.exe" } else { "nm" };
-    let path = std::env::var_os("PATH")
-        .ok_or_else(|| FbuildError::Other("PATH not set".into()))?;
+    let path = std::env::var_os("PATH").ok_or_else(|| FbuildError::Other("PATH not set".into()))?;
     for dir in std::env::split_paths(&path) {
         let candidate = dir.join(exe_name);
         if candidate.exists() {

crates/fbuild-core/src/symbol_analysis.rs

@@ -135,7 +135,7 @@ pub fn extract_archive_and_object(src: &str) -> (Option<String>, String) {
         let archive_end = open + 2; // include ".a"
         let archive_path = &trimmed[..archive_end];
         let archive = archive_path
-            .rsplit(|c| c == '/' || c == '\\')
+            .rsplit(['/', '\\'])
             .next()
             .unwrap_or(archive_path)
             .to_string();
@@ -149,7 +149,7 @@ pub fn extract_archive_and_object(src: &str) -> (Option<String>, String) {
     }
     // Form B: ".../<file>.o" — no archive, just an object on disk.
     let basename = trimmed
-        .rsplit(|c| c == '/' || c == '\\')
+        .rsplit(['/', '\\'])
         .next()
         .unwrap_or(trimmed)
         .to_string();
@@ -310,7 +310,7 @@ impl InputSectionIndex {
     pub fn lookup(&self, addr: u64) -> Option<&InputSectionRange> {
         let (_, &idx) = self.by_start.range(..=addr).next_back()?;
         let r = &self.ranges[idx];
-        if addr < r.addr.checked_add(r.size).unwrap_or(u64::MAX) {
+        if addr < r.addr.saturating_add(r.size) {
             Some(r)
         } else {
             None
@@ -334,7 +334,11 @@ pub fn rollup_sections(ranges: &[InputSectionRange]) -> Vec<SectionBytes> {
         if !is_firmware_section(&r.output_section) {
             continue;
         }
-        let key = (r.archive.clone(), r.object.clone(), r.output_section.clone());
+        let key = (
+            r.archive.clone(),
+            r.object.clone(),
+            r.output_section.clone(),
+        );
         *acc.entry(key).or_insert(0) += r.size;
     }
     let mut out: Vec<SectionBytes> = acc
@@ -455,9 +459,7 @@ mod tests {
 
     #[test]
     fn extract_bare_object_no_archive() {
-        let (arc, obj) = extract_archive_and_object(
-            ".pio/build/esp32s3/src/main.cpp.o",
-        );
+        let (arc, obj) = extract_archive_and_object(".pio/build/esp32s3/src/main.cpp.o");
         assert!(arc.is_none());
         assert_eq!(obj, "main.cpp.o");
     }
@@ -557,7 +559,12 @@ Linker script and memory map
             archive: Some("libFastLED.a".into()),
             object: "fl.channels.cpp.o".into(),
         }];
-        let nm = vec![(0x42000020u64, 0x40u64, 'T', "_ZN2fl7Channel10showPixelsERS_".to_string())];
+        let nm = vec![(
+            0x42000020u64,
+            0x40u64,
+            'T',
+            "_ZN2fl7Channel10showPixelsERS_".to_string(),
+        )];
         let demangled = vec!["fl::Channel::showPixels(fl::Channel&)".to_string()];
         let map = build_fine_grained_map(
             "fw.elf".into(),

dylints/ban_raw_subprocess/src/allowlist.txt

@@ -45,3 +45,12 @@ crates/fbuild-build/src/zccache.rs
 # `containment::tokio_spawn::spawn_contained` would be a no-op anyway;
 # documented inline at each call site.
 crates/fbuild-cli/src/cli/clang_tools.rs
+
+# `fbuild symbols` demangles via c++filt. We pipe the mangled symbol
+# list through c++filt's stdin and drain stdout via `wait_with_output`
+# from a separate writer thread to avoid the Windows pipe-buffer
+# deadlock that hits when the symbol pool is large. The captured
+# `subprocess::run_command` helper is stdin-Null only, so raw spawn is
+# the only way to feed the pipe. Read-only analysis path (no
+# containment side effects).
+crates/fbuild-build/src/symbol_analyzer.rs