fix(uffs-mft): convert last 2 blanket #[allow(dead_code)] to #[expect] + rustfmt

Convert FILE_NAME_WIN32 and FILE_NAME_WIN32_DOS constants from
#[allow(dead_code)] to #[expect(dead_code, reason="...")] to match
the pattern established across all other crates. Also applies
rustfmt to fix formatting drift from the merge to main.

Result: 0 blanket #[allow] remaining across all in-scope crates.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: githubrobbi

crates/uffs-cli/src/commands.rs

@@ -1607,8 +1607,9 @@ fn results_to_dataframe(
         // For directories (including reparse), always prefer the record's tree metrics
         // to ensure we get the computed values from cpp_tree, not potentially stale
         // values from SearchResult.
-        // C++ parity: ADS entries (stream_index > 0) have descendants/treesize/tree_allocated = 0.
-        // Only the default stream (stream_index == 0) gets tree metrics.
+        // C++ parity: ADS entries (stream_index > 0) have
+        // descendants/treesize/tree_allocated = 0. Only the default stream
+        // (stream_index == 0) gets tree metrics.
         let (desc, tsize, talloc) = if result.stream_index > 0 {
             // ADS stream: no tree metrics
             (0_u32, 0_u64, 0_u64)

crates/uffs-cli/src/main.rs

@@ -46,12 +46,13 @@ use std::io;
 use std::path::{Path, PathBuf};
 
 use anyhow::Result;
+use chrono as _;
 use clap::{Parser, Subcommand};
 use mimalloc::MiMalloc;
 use tracing_subscriber::fmt::time::UtcTime;
 use tracing_subscriber::layer::SubscriberExt;
 use tracing_subscriber::{EnvFilter, Layer};
-use {chrono as _, uffs_polars as _};
+use uffs_polars as _;
 
 /// Use mimalloc globally - faster than system allocator for our workload:
 /// many small allocations (file names, records) + large buffers (MFT,

crates/uffs-core/src/compiled_pattern.rs

@@ -227,7 +227,9 @@ impl CompiledPattern {
             Self::ContainsAny(patterns) => {
                 if case_sensitive {
                     let series = Series::new(PlSmallStr::EMPTY, patterns);
-                    col_expr.str().contains_any(lit(series).implode(true), false)
+                    col_expr
+                        .str()
+                        .contains_any(lit(series).implode(true), false)
                 } else {
                     // Use ascii_case_insensitive=true for case-insensitive matching
                     let series = Series::new(PlSmallStr::EMPTY, patterns);

crates/uffs-core/src/tree.rs

@@ -600,8 +600,7 @@ pub fn apply_directory_treesize(df: &DataFrame) -> Result<DataFrame> {
     let has_stream_name = df.column("stream_name").is_ok();
 
     let is_default_dir = if has_stream_name {
-        col("is_directory")
-            .and(col("stream_name").eq(lit("")))
+        col("is_directory").and(col("stream_name").eq(lit("")))
     } else {
         col("is_directory")
     };

crates/uffs-diag/src/lib.rs

@@ -10,7 +10,11 @@
 
 // Keep dependencies wired in for version-locking, even though the library
 // portion does not use them directly (the binaries do).
-use {anyhow as _, chrono as _, rayon as _, uffs_mft as _, uffs_polars as _};
+use anyhow as _;
+use chrono as _;
+use rayon as _;
+use uffs_mft as _;
+use uffs_polars as _;
 
 /// Windows-only helpers for inspecting the full uffs-mft raw->fixup->parse
 /// pipeline for a single FRS.

crates/uffs-mft/benches/mft_read.rs

@@ -12,12 +12,26 @@
 //! ```
 
 // Suppress unused crate warnings for dependencies used by the main crate.
-use {
-    anyhow as _, bitflags as _, chrono as _, clap as _, criterion as _, dirs_next as _,
-    hostname as _, indicatif as _, num_cpus as _, proptest as _, rayon as _, rustc_hash as _,
-    smallvec as _, thiserror as _, tokio as _, tracing as _, tracing_appender as _,
-    tracing_subscriber as _, uffs_mft as _, uffs_polars as _,
-};
+use anyhow as _;
+use bitflags as _;
+use chrono as _;
+use clap as _;
+use criterion as _;
+use dirs_next as _;
+use hostname as _;
+use indicatif as _;
+use num_cpus as _;
+use proptest as _;
+use rayon as _;
+use rustc_hash as _;
+use smallvec as _;
+use thiserror as _;
+use tokio as _;
+use tracing as _;
+use tracing_appender as _;
+use tracing_subscriber as _;
+use uffs_mft as _;
+use uffs_polars as _;
 
 #[cfg(feature = "zstd")]
 extern crate zstd as _;

crates/uffs-mft/src/cpp_types.rs

@@ -1718,7 +1718,10 @@ const FRH_IN_USE: u16 = 0x0001;
 const FRH_DIRECTORY: u16 = 0x0002;
 
 /// NTFS `FILE_NAME` namespace: Win32 (case-insensitive, visible in Explorer).
-#[allow(dead_code)]
+#[expect(
+    dead_code,
+    reason = "defined for completeness of NTFS namespace constants"
+)]
 const FILE_NAME_WIN32: u8 = 0x01;
 /// NTFS `FILE_NAME` namespace: DOS-only (8.3 short name, not visible
 /// standalone).
@@ -1728,7 +1731,10 @@ const FILE_NAME_WIN32: u8 = 0x01;
 )]
 const FILE_NAME_DOS: u8 = 0x02;
 /// NTFS `FILE_NAME` namespace: Win32+DOS combined (visible in Explorer).
-#[allow(dead_code)]
+#[expect(
+    dead_code,
+    reason = "defined for completeness of NTFS namespace constants"
+)]
 const FILE_NAME_WIN32_DOS: u8 = 0x03;
 
 /// FILE record magic number ('FILE' in little-endian = 'ELIF')
@@ -2317,8 +2323,8 @@ impl CppParsePipeline {
             unsafe { core::ptr::read(attr_data[value_offset..].as_ptr().cast()) };
 
         // C++ parity: skip only DOS-only (0x02) namespace.
-        // C++ code: `if (fn->Flags != 0x02 /*FILE_NAME_DOS */)` (ntfs_index.hpp line 550)
-        // Accepts POSIX (0x00), Win32 (0x01), and Win32+DOS (0x03).
+        // C++ code: `if (fn->Flags != 0x02 /*FILE_NAME_DOS */)` (ntfs_index.hpp line
+        // 550) Accepts POSIX (0x00), Win32 (0x01), and Win32+DOS (0x03).
         let namespace = fn_attr.file_name_namespace;
         if namespace == FILE_NAME_DOS {
             return;
@@ -2344,7 +2350,8 @@ impl CppParsePipeline {
         let record_idx = index.records_lookup[frs_base as usize] as usize;
 
         // C++ parity: no deduplication. If record already has a name, push
-        // current first_name to overflow list (matches C++ ntfs_index.hpp lines 552-557).
+        // current first_name to overflow list (matches C++ ntfs_index.hpp lines
+        // 552-557).
         let current_name_count = index.records_data[record_idx].name_count;
         if current_name_count > 0 {
             // Push current first_name to overflow list

crates/uffs-mft/src/index.rs

@@ -2280,8 +2280,8 @@ impl MftIndex {
 
         tracing::debug!("[TRIP] MftIndex::compute_tree_metrics_cpp_port EXIT");
     }
-    // NOTE: compute_tree_metrics_impl was removed - cpp_port is now the sole algorithm.
-    // See commit "refactor: remove algorithm selection machinery"
+    // NOTE: compute_tree_metrics_impl was removed - cpp_port is now the sole
+    // algorithm. See commit "refactor: remove algorithm selection machinery"
 
     /// Display enhanced statistics to stdout.
     ///
@@ -5402,9 +5402,10 @@ mod tests {
             "Directory should have descendants = 2"
         );
 
-        // Root's size = children.length (Channel A from directory) + root's first_len (0)
-        // Channel A from directory = file_delta(1000) + internal_stream_delta(256) = 1256
-        // Root treesize (Channel B) = 1256 + 0 = 1256
+        // Root's size = children.length (Channel A from directory) + root's first_len
+        // (0) Channel A from directory = file_delta(1000) +
+        // internal_stream_delta(256) = 1256 Root treesize (Channel B) = 1256 +
+        // 0 = 1256
         let root_idx = index.frs_to_idx_opt(root_frs).unwrap();
         assert_eq!(
             index.records[root_idx].treesize, 1256,

crates/uffs-mft/src/io.rs

@@ -646,8 +646,14 @@ pub fn parse_record_to_index(data: &[u8], frs: u64, index: &mut crate::index::Mf
                                 };
                                 if is_better || primary_name.is_none() {
                                     // Move old primary to additional if exists
-                                    if let Some((old_name, old_parent, _, old_parse_idx)) = primary_name.take() {
-                                        additional_names.push((old_name, old_parent, old_parse_idx));
+                                    if let Some((old_name, old_parent, _, old_parse_idx)) =
+                                        primary_name.take()
+                                    {
+                                        additional_names.push((
+                                            old_name,
+                                            old_parent,
+                                            old_parse_idx,
+                                        ));
                                     }
                                     primary_name = Some((name, parent_frs, namespace, parse_idx));
                                 } else {
@@ -667,9 +673,7 @@ pub fn parse_record_to_index(data: &[u8], frs: u64, index: &mut crate::index::Mf
                     let nr_offset = offset + 16;
                     if nr_offset + 8 <= data.len() {
                         let lowest_vcn = i64::from_le_bytes(
-                            data[nr_offset..nr_offset + 8]
-                                .try_into()
-                                .unwrap_or([0; 8]),
+                            data[nr_offset..nr_offset + 8].try_into().unwrap_or([0; 8]),
                         );
                         lowest_vcn == 0
                     } else {
@@ -835,7 +839,8 @@ pub fn parse_record_to_index(data: &[u8], frs: u64, index: &mut crate::index::Mf
     let additional_count = additional_names.len();
     let mut link_indices: Vec<u32> = Vec::with_capacity(additional_count);
     // Collect parent FRS values for building children array later
-    let mut additional_parent_frs: SmallVec<[(u64, u16); 4]> = SmallVec::with_capacity(additional_count);
+    let mut additional_parent_frs: SmallVec<[(u64, u16); 4]> =
+        SmallVec::with_capacity(additional_count);
     for (link_name, link_parent, link_parse_idx) in additional_names {
         additional_parent_frs.push((link_parent, link_parse_idx));
         let link_offset = index.add_name(&link_name);
@@ -1083,9 +1088,7 @@ fn parse_extension_to_index(
                     let nr_offset = offset + 16;
                     if nr_offset + 8 <= data.len() {
                         let lowest_vcn = i64::from_le_bytes(
-                            data[nr_offset..nr_offset + 8]
-                                .try_into()
-                                .unwrap_or([0; 8]),
+                            data[nr_offset..nr_offset + 8].try_into().unwrap_or([0; 8]),
                         );
                         lowest_vcn == 0
                     } else {
@@ -1517,8 +1520,14 @@ pub fn parse_record_to_fragment(
                                     _ => false,
                                 };
                                 if is_better || primary_name.is_none() {
-                                    if let Some((old_name, old_parent, _, old_parse_idx)) = primary_name.take() {
-                                        additional_names.push((old_name, old_parent, old_parse_idx));
+                                    if let Some((old_name, old_parent, _, old_parse_idx)) =
+                                        primary_name.take()
+                                    {
+                                        additional_names.push((
+                                            old_name,
+                                            old_parent,
+                                            old_parse_idx,
+                                        ));
                                     }
                                     primary_name = Some((name, parent_frs, namespace, parse_idx));
                                 } else {
@@ -1538,9 +1547,7 @@ pub fn parse_record_to_fragment(
                     let nr_offset = offset + 16;
                     if nr_offset + 8 <= data.len() {
                         let lowest_vcn = i64::from_le_bytes(
-                            data[nr_offset..nr_offset + 8]
-                                .try_into()
-                                .unwrap_or([0; 8]),
+                            data[nr_offset..nr_offset + 8].try_into().unwrap_or([0; 8]),
                         );
                         lowest_vcn == 0
                     } else {
@@ -1702,7 +1709,8 @@ pub fn parse_record_to_fragment(
     let additional_count = additional_names.len();
     let mut link_indices: Vec<u32> = Vec::with_capacity(additional_count);
     // Collect parent FRS values for building children array later
-    let mut additional_parent_frs: SmallVec<[(u64, u16); 4]> = SmallVec::with_capacity(additional_count);
+    let mut additional_parent_frs: SmallVec<[(u64, u16); 4]> =
+        SmallVec::with_capacity(additional_count);
     for (link_name, link_parent, link_parse_idx) in additional_names {
         additional_parent_frs.push((link_parent, link_parse_idx));
         let link_offset = fragment.add_name(&link_name);
@@ -2028,9 +2036,7 @@ fn parse_extension_to_fragment(
                     let nr_offset = offset + 16;
                     if nr_offset + 8 <= data.len() {
                         let lowest_vcn = i64::from_le_bytes(
-                            data[nr_offset..nr_offset + 8]
-                                .try_into()
-                                .unwrap_or([0; 8]),
+                            data[nr_offset..nr_offset + 8].try_into().unwrap_or([0; 8]),
                         );
                         lowest_vcn == 0
                     } else {
@@ -5348,8 +5354,10 @@ impl ParallelMftReader {
     ///
     /// This method uses a producer-consumer pattern:
     /// - IOCP thread reads data and sends buffers to a channel
-    /// - Worker threads parse buffers using `parse_record_full()` (unified pipeline)
-    /// - After all I/O completes, results are merged via `MftRecordMerger` into final index
+    /// - Worker threads parse buffers using `parse_record_full()` (unified
+    ///   pipeline)
+    /// - After all I/O completes, results are merged via `MftRecordMerger` into
+    ///   final index
     ///
     /// This is beneficial for NVMe drives where I/O is faster than parsing.
     /// For HDD, use `read_all_sliding_window_iocp_to_index` (inline parsing).

crates/uffs-mft/src/main.rs

@@ -41,6 +41,7 @@ use std::io;
 use std::path::{Path, PathBuf};
 
 use anyhow::{Context, Result};
+use bitflags as _;
 use clap::{Parser, Subcommand};
 // Dev-dependencies (used in benchmarks and tests only)
 #[cfg(test)]
@@ -55,8 +56,11 @@ use indicatif as _;
 use indicatif::{ProgressBar, ProgressStyle};
 #[cfg(test)]
 use proptest as _;
+use rayon as _;
+use rustc_hash as _;
 // SmallVec for path chain building (used in index.rs PathResolver)
 use smallvec as _;
+use thiserror as _;
 #[cfg(not(windows))]
 use tracing as _;
 #[cfg(windows)]
@@ -71,10 +75,10 @@ use tracing_subscriber::{EnvFilter, Layer};
 use uffs_mft as _;
 #[cfg(windows)]
 use uffs_mft::MftReader;
+use uffs_polars as _;
 // Optional dependencies
 #[cfg(feature = "zstd")]
 use zstd as _;
-use {bitflags as _, rayon as _, rustc_hash as _, thiserror as _, uffs_polars as _};
 // Benchmark dependencies (used by bench/bench-all commands on Windows)
 #[cfg(not(windows))]
 use {chrono as _, hostname as _, num_cpus as _};