fix: csspell - Rename Mmap to FileRead, use memory-map in comment and alias Mmap as MemoryMap

Author: nonontb

src/uu/sort/src/merge.rs

@@ -28,7 +28,7 @@ use std::{
 };
 
 use compare::Compare;
-use memmap2::Mmap;
+use memmap2::Mmap as MemoryMap;
 use uucore::error::{FromIo, UResult};
 
 use crate::{
@@ -76,9 +76,9 @@ pub fn merge(
     output: Output,
     tmp_dir: &mut TmpDirWrapper,
 ) -> UResult<()> {
-    // If the output file is also listed as an input, pre-mmap it before
+    // If the output file is also listed as an input, Use memory-map to load it before
     // it gets opened for writing. This allows reading the original content
-    // via mmap while writing to the same file, without needing a temp copy.
+    // via memory-map while writing to the same file, without needing a temp copy.
     let output_as_input = if let Some(name) = output.as_output_name() {
         let output_path = Path::new(name).canonicalize()?;
         let appears = files
@@ -89,16 +89,17 @@ pub fn merge(
                 path: output_path.clone(),
                 error,
             })?;
-            // SAFETY: We keep the read_fd open for the lifetime of the mmap,
+            // SAFETY: We keep the read_fd open for the lifetime of the memory-map,
             // and we only read from it. The file is not modified while the
-            // mmap exists (writing happens later via a separate FD).
-            let mmap = Arc::new(unsafe { Mmap::map(&read_fd) }.map_err(|error| {
-                SortError::ReadFailed {
-                    path: output_path.clone(),
-                    error,
-                }
-            })?);
-            Some((output_path, mmap))
+            // memory-map exists (writing happens later via a separate FD).
+            let output_as_input =
+                Arc::new(unsafe { MemoryMap::map(&read_fd) }.map_err(|error| {
+                    SortError::ReadFailed {
+                        path: output_path.clone(),
+                        error,
+                    }
+                })?);
+            Some((output_path, output_as_input))
         } else {
             None
         }
@@ -640,10 +641,11 @@ mod tests {
         // Check Opened SortInputs: 7 inputs but only 6 unique sources
         let output_canon = out.path().canonicalize().unwrap();
         let read_fd = File::open(out.path()).unwrap();
-        let output_mmap = Arc::new(unsafe { Mmap::map(&read_fd).unwrap() });
+        let output_as_input = Arc::new(unsafe { MemoryMap::map(&read_fd).unwrap() });
 
         let sort_inputs =
-            SortInputs::from_files_with_output(&files, Some((output_canon, output_mmap))).unwrap();
+            SortInputs::from_files_with_output(&files, Some((output_canon, output_as_input)))
+                .unwrap();
 
         assert_eq!(sort_inputs.len(), 7);
         assert_eq!(sort_inputs.unique_count(), 6);
@@ -656,7 +658,7 @@ mod tests {
 
         merge(&mut files_mut, &settings, output, &mut tmp_dir).unwrap();
 
-        // If merge succeeded with only 6 unique sources, mmap deduplication worked.
+        // If merge succeeded with only 6 unique sources, memory-map deduplication worked.
         // Verify correctness.
         let result = fs::read_to_string(out.path()).unwrap();
         assert_eq!(result, "1\n2\n3\n4\n5\n6\n6\n");

src/uu/sort/src/sort_input.rs

@@ -19,7 +19,7 @@ use std::{
     },
 };
 
-use memmap2::Mmap;
+use memmap2::Mmap as MemoryMap;
 use uucore::error::UResult;
 
 use crate::{STDIN_FILE, SortError};
@@ -31,8 +31,8 @@ enum SortInputInner {
     File(File),
     /// A memory-mapped file shared across duplicate paths, with an
     /// independent cursor per instance.
-    Mmap {
-        data: Arc<Mmap>,
+    FileRead {
+        data: Arc<MemoryMap>,
         offset: AtomicUsize,
     },
     Stdin,
@@ -68,9 +68,9 @@ impl SortInput {
         }
     }
 
-    fn from_mmap(data: Arc<Mmap>) -> Self {
+    fn from_mmap(data: Arc<MemoryMap>) -> Self {
         Self {
-            inner: SortInputInner::Mmap {
+            inner: SortInputInner::FileRead {
                 data,
                 offset: AtomicUsize::new(0),
             },
@@ -93,7 +93,7 @@ impl Read for SortInput {
 
         match &mut self.inner {
             SortInputInner::File(file) => file.read(buf),
-            SortInputInner::Mmap { data, offset } => {
+            SortInputInner::FileRead { data, offset } => {
                 let pos = offset.load(Ordering::Relaxed);
                 let available = data.len().saturating_sub(pos);
                 let to_read = buf.len().min(available);
@@ -142,7 +142,7 @@ impl SortInputs {
     /// - `output_as_input`: pre-created mmap used when the output file is also an input.
     pub fn from_files_with_output(
         files: &[std::ffi::OsString],
-        output_as_input: Option<(PathBuf, Arc<Mmap>)>,
+        output_as_input: Option<(PathBuf, Arc<MemoryMap>)>,
     ) -> UResult<Self> {
         let mut inputs = Vec::with_capacity(files.len());
 
@@ -161,7 +161,7 @@ impl SortInputs {
         // - Duplicate files: mmap once, share it
         // - Output-as-input: use pre-created mmap
         // - Stdin: single occurrence
-        let mut opened_files: HashMap<PathBuf, Arc<Mmap>> = HashMap::new();
+        let mut opened_files: HashMap<PathBuf, Arc<MemoryMap>> = HashMap::new();
 
         for file in files {
             if file == STDIN_FILE {
@@ -191,7 +191,7 @@ impl SortInputs {
                         })?;
                         // SAFETY: We keep the file open for the lifetime of the mmap,
                         // and we only read from it. The file is not modified.
-                        let mmap = Arc::new(unsafe { Mmap::map(&f) }.map_err(|error| {
+                        let mmap = Arc::new(unsafe { MemoryMap::map(&f) }.map_err(|error| {
                             SortError::ReadFailed {
                                 path: path.to_owned(),
                                 error,
@@ -244,7 +244,7 @@ impl SortInputs {
                 SortInputInner::File(_) | SortInputInner::LazyFile(_) => {
                     file_count += 1;
                 }
-                SortInputInner::Mmap { data, .. } => {
+                SortInputInner::FileRead { data, .. } => {
                     seen_mmaps.insert(Arc::as_ptr(data));
                 }
             }
@@ -350,7 +350,7 @@ mod tests {
         tmpfile.flush().expect("should flush temp file");
 
         let file = File::open(tmpfile.path()).expect("should open temp file");
-        let mmap = Arc::new(unsafe { Mmap::map(&file).expect("should mmap temp file") });
+        let mmap = Arc::new(unsafe { MemoryMap::map(&file).expect("should mmap temp file") });
         let mut input = SortInput::from_mmap(mmap);
 
         let mut buf = [0u8; 14];
@@ -368,7 +368,7 @@ mod tests {
         tmpfile.flush().expect("should flush temp file");
 
         let file = File::open(tmpfile.path()).expect("should open temp file");
-        let mmap = Arc::new(unsafe { Mmap::map(&file).expect("should mmap temp file") });
+        let mmap = Arc::new(unsafe { MemoryMap::map(&file).expect("should mmap temp file") });
         let input = SortInput::from_mmap(mmap);
         let mut reader: Box<dyn Read + Send> = input.into();
         let mut buf = [0u8; 9];
@@ -388,7 +388,7 @@ mod tests {
         tmpfile.flush().expect("should flush temp file");
 
         let file = File::open(tmpfile.path()).expect("should open temp file");
-        let mmap = Arc::new(unsafe { Mmap::map(&file).expect("should mmap temp file") });
+        let mmap = Arc::new(unsafe { MemoryMap::map(&file).expect("should mmap temp file") });
 
         let mut input1 = SortInput::from_mmap(mmap.clone());
         let mut input2 = SortInput::from_mmap(mmap);
@@ -493,7 +493,7 @@ mod tests {
         let mut buf1 = [0u8; 11];
         let mut input1 = SortInput {
             inner: match &inputs.iter().next().expect("should get first input").inner {
-                SortInputInner::Mmap { data, offset } => SortInputInner::Mmap {
+                SortInputInner::FileRead { data, offset } => SortInputInner::FileRead {
                     data: data.clone(),
                     offset: AtomicUsize::new(offset.load(Ordering::Relaxed)),
                 },
@@ -508,7 +508,7 @@ mod tests {
         let mut buf2 = [0u8; 11];
         let mut input2 = SortInput {
             inner: match &inputs.iter().nth(1).expect("should get second input").inner {
-                SortInputInner::Mmap { data, offset } => SortInputInner::Mmap {
+                SortInputInner::FileRead { data, offset } => SortInputInner::FileRead {
                     data: data.clone(),
                     offset: AtomicUsize::new(offset.load(Ordering::Relaxed)),
                 },