rust-dirstate: remove unneeded "ref"

At 7cae6bc29ff9, .to_owned() was rewritten as .to_owned().to_vec(), which
is no longer needed since the filename is a single reference.

rust/hg-core/src/dirstate/parsers.rs

@@ -1,415 +1,415 b''
 // Copyright 2019 Raphaël Gomès <[e-mail]>
 //
 // This software may be used and distributed according to the terms of the
 // GNU General Public License version 2 or any later version.
 
 use crate::{
     dirstate::{CopyMap, EntryState, StateMap},
     utils::copy_into_array,
     DirstateEntry, DirstatePackError, DirstateParents, DirstateParseError,
 };
 use byteorder::{BigEndian, ReadBytesExt, WriteBytesExt};
 use std::convert::{TryFrom, TryInto};
 use std::io::Cursor;
 use std::time::Duration;
 
 /// Parents are stored in the dirstate as byte hashes.
 pub const PARENT_SIZE: usize = 20;
 /// Dirstate entries have a static part of 8 + 32 + 32 + 32 + 32 bits.
 const MIN_ENTRY_SIZE: usize = 17;
 
 // TODO parse/pack: is mutate-on-loop better for performance?
 
 pub fn parse_dirstate(
     state_map: &mut StateMap,
     copy_map: &mut CopyMap,
     contents: &[u8],
 ) -> Result<DirstateParents, DirstateParseError> {
     if contents.len() < PARENT_SIZE * 2 {
         return Err(DirstateParseError::TooLittleData);
     }
 
     let mut curr_pos = PARENT_SIZE * 2;
     let parents = DirstateParents {
         p1: copy_into_array(&contents[..PARENT_SIZE]),
         p2: copy_into_array(&contents[PARENT_SIZE..curr_pos]),
     };
 
     while curr_pos < contents.len() {
         if curr_pos + MIN_ENTRY_SIZE > contents.len() {
             return Err(DirstateParseError::Overflow);
         }
         let entry_bytes = &contents[curr_pos..];
 
         let mut cursor = Cursor::new(entry_bytes);
         let state = EntryState::try_from(cursor.read_u8()?)?;
         let mode = cursor.read_i32::<BigEndian>()?;
         let size = cursor.read_i32::<BigEndian>()?;
         let mtime = cursor.read_i32::<BigEndian>()?;
         let path_len = cursor.read_i32::<BigEndian>()? as usize;
 
         if path_len > contents.len() - curr_pos {
             return Err(DirstateParseError::Overflow);
         }
 
         // Slice instead of allocating a Vec needed for `read_exact`
         let path = &entry_bytes[MIN_ENTRY_SIZE..MIN_ENTRY_SIZE + (path_len)];
 
         let (path, copy) = match memchr::memchr(0, path) {
             None => (path, None),
             Some(i) => (&path[..i], Some(&path[(i + 1)..])),
         };
 
         if let Some(copy_path) = copy {
             copy_map.insert(path.to_owned(), copy_path.to_owned());
         };
         state_map.insert(
             path.to_owned(),
             DirstateEntry {
                 state,
                 mode,
                 size,
                 mtime,
             },
         );
         curr_pos = curr_pos + MIN_ENTRY_SIZE + (path_len);
     }
 
     Ok(parents)
 }
 
 /// `now` is the duration in seconds since the Unix epoch
 pub fn pack_dirstate(
     state_map: &mut StateMap,
     copy_map: &CopyMap,
     parents: DirstateParents,
     now: Duration,
 ) -> Result<Vec<u8>, DirstatePackError> {
     // TODO move away from i32 before 2038.
     let now: i32 = now.as_secs().try_into().expect("time overflow");
 
     let expected_size: usize = state_map
         .iter()
         .map(|(filename, _)| {
             let mut length = MIN_ENTRY_SIZE + filename.len();
-            if let Some(ref copy) = copy_map.get(filename) {
+            if let Some(copy) = copy_map.get(filename) {
                 length += copy.len() + 1;
             }
             length
         })
         .sum();
     let expected_size = expected_size + PARENT_SIZE * 2;
 
     let mut packed = Vec::with_capacity(expected_size);
     let mut new_state_map = vec![];
 
     packed.extend(&parents.p1);
     packed.extend(&parents.p2);
 
-    for (ref filename, entry) in state_map.iter() {
-        let mut new_filename: Vec<u8> = filename.to_vec();
+    for (filename, entry) in state_map.iter() {
+        let mut new_filename: Vec<u8> = filename.to_owned();
         let mut new_mtime: i32 = entry.mtime;
         if entry.state == EntryState::Normal && entry.mtime == now {
             // The file was last modified "simultaneously" with the current
             // write to dirstate (i.e. within the same second for file-
             // systems with a granularity of 1 sec). This commonly happens
             // for at least a couple of files on 'update'.
             // The user could change the file without changing its size
             // within the same second. Invalidate the file's mtime in
             // dirstate, forcing future 'status' calls to compare the
             // contents of the file if the size is the same. This prevents
             // mistakenly treating such files as clean.
             new_mtime = -1;
             new_state_map.push((
-                filename.to_owned().to_vec(),
+                filename.to_owned(),
                 DirstateEntry {
                     mtime: new_mtime,
                     ..*entry
                 },
             ));
         }
 
-        if let Some(copy) = copy_map.get(*filename) {
+        if let Some(copy) = copy_map.get(filename) {
             new_filename.push('\0' as u8);
             new_filename.extend(copy);
         }
 
         packed.write_u8(entry.state.into())?;
         packed.write_i32::<BigEndian>(entry.mode)?;
         packed.write_i32::<BigEndian>(entry.size)?;
         packed.write_i32::<BigEndian>(new_mtime)?;
         packed.write_i32::<BigEndian>(new_filename.len() as i32)?;
         packed.extend(new_filename)
     }
 
     if packed.len() != expected_size {
         return Err(DirstatePackError::BadSize(expected_size, packed.len()));
     }
 
     state_map.extend(new_state_map);
 
     Ok(packed)
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
     use std::collections::HashMap;
 
     #[test]
     fn test_pack_dirstate_empty() {
         let mut state_map: StateMap = HashMap::new();
         let copymap = HashMap::new();
         let parents = DirstateParents {
             p1: *b"12345678910111213141",
             p2: *b"00000000000000000000",
         };
         let now = Duration::new(15000000, 0);
         let expected = b"1234567891011121314100000000000000000000".to_vec();
 
         assert_eq!(
             expected,
             pack_dirstate(&mut state_map, &copymap, parents, now).unwrap()
         );
 
         assert!(state_map.is_empty())
     }
     #[test]
     fn test_pack_dirstate_one_entry() {
         let expected_state_map: StateMap = [(
             b"f1".to_vec(),
             DirstateEntry {
                 state: EntryState::Normal,
                 mode: 0o644,
                 size: 0,
                 mtime: 791231220,
             },
         )]
         .iter()
         .cloned()
         .collect();
         let mut state_map = expected_state_map.clone();
 
         let copymap = HashMap::new();
         let parents = DirstateParents {
             p1: *b"12345678910111213141",
             p2: *b"00000000000000000000",
         };
         let now = Duration::new(15000000, 0);
         let expected = [
             49, 50, 51, 52, 53, 54, 55, 56, 57, 49, 48, 49, 49, 49, 50, 49,
             51, 49, 52, 49, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
             48, 48, 48, 48, 48, 48, 48, 48, 110, 0, 0, 1, 164, 0, 0, 0, 0, 47,
             41, 58, 244, 0, 0, 0, 2, 102, 49,
         ]
         .to_vec();
 
         assert_eq!(
             expected,
             pack_dirstate(&mut state_map, &copymap, parents, now).unwrap()
         );
 
         assert_eq!(expected_state_map, state_map);
     }
     #[test]
     fn test_pack_dirstate_one_entry_with_copy() {
         let expected_state_map: StateMap = [(
             b"f1".to_vec(),
             DirstateEntry {
                 state: EntryState::Normal,
                 mode: 0o644,
                 size: 0,
                 mtime: 791231220,
             },
         )]
         .iter()
         .cloned()
         .collect();
         let mut state_map = expected_state_map.clone();
         let mut copymap = HashMap::new();
         copymap.insert(b"f1".to_vec(), b"copyname".to_vec());
         let parents = DirstateParents {
             p1: *b"12345678910111213141",
             p2: *b"00000000000000000000",
         };
         let now = Duration::new(15000000, 0);
         let expected = [
             49, 50, 51, 52, 53, 54, 55, 56, 57, 49, 48, 49, 49, 49, 50, 49,
             51, 49, 52, 49, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48, 48,
             48, 48, 48, 48, 48, 48, 48, 48, 110, 0, 0, 1, 164, 0, 0, 0, 0, 47,
             41, 58, 244, 0, 0, 0, 11, 102, 49, 0, 99, 111, 112, 121, 110, 97,
             109, 101,
         ]
         .to_vec();
 
         assert_eq!(
             expected,
             pack_dirstate(&mut state_map, &copymap, parents, now).unwrap()
         );
         assert_eq!(expected_state_map, state_map);
     }
 
     #[test]
     fn test_parse_pack_one_entry_with_copy() {
         let mut state_map: StateMap = [(
             b"f1".to_vec(),
             DirstateEntry {
                 state: EntryState::Normal,
                 mode: 0o644,
                 size: 0,
                 mtime: 791231220,
             },
         )]
         .iter()
         .cloned()
         .collect();
         let mut copymap = HashMap::new();
         copymap.insert(b"f1".to_vec(), b"copyname".to_vec());
         let parents = DirstateParents {
             p1: *b"12345678910111213141",
             p2: *b"00000000000000000000",
         };
         let now = Duration::new(15000000, 0);
         let result =
             pack_dirstate(&mut state_map, &copymap, parents.clone(), now)
                 .unwrap();
 
         let mut new_state_map: StateMap = HashMap::new();
         let mut new_copy_map: CopyMap = HashMap::new();
         let new_parents = parse_dirstate(
             &mut new_state_map,
             &mut new_copy_map,
             result.as_slice(),
         )
         .unwrap();
         assert_eq!(
             (parents, state_map, copymap),
             (new_parents, new_state_map, new_copy_map)
         )
     }
 
     #[test]
     fn test_parse_pack_multiple_entries_with_copy() {
         let mut state_map: StateMap = [
             (
                 b"f1".to_vec(),
                 DirstateEntry {
                     state: EntryState::Normal,
                     mode: 0o644,
                     size: 0,
                     mtime: 791231220,
                 },
             ),
             (
                 b"f2".to_vec(),
                 DirstateEntry {
                     state: EntryState::Merged,
                     mode: 0o777,
                     size: 1000,
                     mtime: 791231220,
                 },
             ),
             (
                 b"f3".to_vec(),
                 DirstateEntry {
                     state: EntryState::Removed,
                     mode: 0o644,
                     size: 234553,
                     mtime: 791231220,
                 },
             ),
             (
                 b"f4\xF6".to_vec(),
                 DirstateEntry {
                     state: EntryState::Added,
                     mode: 0o644,
                     size: -1,
                     mtime: -1,
                 },
             ),
         ]
         .iter()
         .cloned()
         .collect();
         let mut copymap = HashMap::new();
         copymap.insert(b"f1".to_vec(), b"copyname".to_vec());
         copymap.insert(b"f4\xF6".to_vec(), b"copyname2".to_vec());
         let parents = DirstateParents {
             p1: *b"12345678910111213141",
             p2: *b"00000000000000000000",
         };
         let now = Duration::new(15000000, 0);
         let result =
             pack_dirstate(&mut state_map, &copymap, parents.clone(), now)
                 .unwrap();
 
         let mut new_state_map: StateMap = HashMap::new();
         let mut new_copy_map: CopyMap = HashMap::new();
         let new_parents = parse_dirstate(
             &mut new_state_map,
             &mut new_copy_map,
             result.as_slice(),
         )
         .unwrap();
         assert_eq!(
             (parents, state_map, copymap),
             (new_parents, new_state_map, new_copy_map)
         )
     }
 
     #[test]
     /// https://www.mercurial-scm.org/repo/hg/rev/af3f26b6bba4
     fn test_parse_pack_one_entry_with_copy_and_time_conflict() {
         let mut state_map: StateMap = [(
             b"f1".to_vec(),
             DirstateEntry {
                 state: EntryState::Normal,
                 mode: 0o644,
                 size: 0,
                 mtime: 15000000,
             },
         )]
         .iter()
         .cloned()
         .collect();
         let mut copymap = HashMap::new();
         copymap.insert(b"f1".to_vec(), b"copyname".to_vec());
         let parents = DirstateParents {
             p1: *b"12345678910111213141",
             p2: *b"00000000000000000000",
         };
         let now = Duration::new(15000000, 0);
         let result =
             pack_dirstate(&mut state_map, &copymap, parents.clone(), now)
                 .unwrap();
 
         let mut new_state_map: StateMap = HashMap::new();
         let mut new_copy_map: CopyMap = HashMap::new();
         let new_parents = parse_dirstate(
             &mut new_state_map,
             &mut new_copy_map,
             result.as_slice(),
         )
         .unwrap();
 
         assert_eq!(
             (
                 parents,
                 [(
                     b"f1".to_vec(),
                     DirstateEntry {
                         state: EntryState::Normal,
                         mode: 0o644,
                         size: 0,
                         mtime: -1
                     }
                 )]
                 .iter()
                 .cloned()
                 .collect::<StateMap>(),
                 copymap,
             ),
             (new_parents, new_state_map, new_copy_map)
         )
     }
 }