rust: simply use TryInto to convert slice to array

Since our rust module depends on TryInto, there's no point to avoid using it.

While rewriting copy_into_array(), I noticed CPython interface doesn't check
the length of the p1/p2 values, which is marked as TODO.

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

@@ -1,426 +1,426
 // dirstate_map.rs
 //
 // 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::{parsers::PARENT_SIZE, EntryState},
-    pack_dirstate, parse_dirstate,
-    utils::copy_into_array,
-    CopyMap, DirsIterable, DirsMultiset, DirstateEntry, DirstateError,
-    DirstateMapError, DirstateParents, DirstateParseError, StateMap,
+    pack_dirstate, parse_dirstate, CopyMap, DirsIterable, DirsMultiset,
+    DirstateEntry, DirstateError, DirstateMapError, DirstateParents,
+    DirstateParseError, StateMap,
 };
 use core::borrow::Borrow;
 use std::collections::{HashMap, HashSet};
+use std::convert::TryInto;
 use std::iter::FromIterator;
 use std::ops::Deref;
 use std::time::Duration;
 
 pub type FileFoldMap = HashMap<Vec<u8>, Vec<u8>>;
 
 const NULL_ID: [u8; 20] = [0; 20];
 const MTIME_UNSET: i32 = -1;
 const SIZE_DIRTY: i32 = -2;
 
 #[derive(Default)]
 pub struct DirstateMap {
     state_map: StateMap,
     pub copy_map: CopyMap,
     file_fold_map: Option<FileFoldMap>,
     pub dirs: Option<DirsMultiset>,
     pub all_dirs: Option<DirsMultiset>,
     non_normal_set: HashSet<Vec<u8>>,
     other_parent_set: HashSet<Vec<u8>>,
     parents: Option<DirstateParents>,
     dirty_parents: bool,
 }
 
 /// Should only really be used in python interface code, for clarity
 impl Deref for DirstateMap {
     type Target = StateMap;
 
     fn deref(&self) -> &Self::Target {
         &self.state_map
     }
 }
 
 impl FromIterator<(Vec<u8>, DirstateEntry)> for DirstateMap {
     fn from_iter<I: IntoIterator<Item = (Vec<u8>, DirstateEntry)>>(
         iter: I,
     ) -> Self {
         Self {
             state_map: iter.into_iter().collect(),
             ..Self::default()
         }
     }
 }
 
 impl DirstateMap {
     pub fn new() -> Self {
         Self::default()
     }
 
     pub fn clear(&mut self) {
         self.state_map.clear();
         self.copy_map.clear();
         self.file_fold_map = None;
         self.non_normal_set.clear();
         self.other_parent_set.clear();
         self.set_parents(DirstateParents {
             p1: NULL_ID,
             p2: NULL_ID,
         })
     }
 
     /// Add a tracked file to the dirstate
     pub fn add_file(
         &mut self,
         filename: &[u8],
         old_state: EntryState,
         entry: DirstateEntry,
     ) {
         if old_state == EntryState::Unknown || old_state == EntryState::Removed
         {
             if let Some(ref mut dirs) = self.dirs {
                 dirs.add_path(filename)
             }
         }
         if old_state == EntryState::Unknown {
             if let Some(ref mut all_dirs) = self.all_dirs {
                 all_dirs.add_path(filename)
             }
         }
         self.state_map.insert(filename.to_owned(), entry.to_owned());
 
         if entry.state != EntryState::Normal || entry.mtime == MTIME_UNSET {
             self.non_normal_set.insert(filename.to_owned());
         }
 
         if entry.size == SIZE_DIRTY {
             self.other_parent_set.insert(filename.to_owned());
         }
     }
 
     /// Mark a file as removed in the dirstate.
     ///
     /// The `size` parameter is used to store sentinel values that indicate
     /// the file's previous state.  In the future, we should refactor this
     /// to be more explicit about what that state is.
     pub fn remove_file(
         &mut self,
         filename: &[u8],
         old_state: EntryState,
         size: i32,
     ) -> Result<(), DirstateMapError> {
         if old_state != EntryState::Unknown && old_state != EntryState::Removed
         {
             if let Some(ref mut dirs) = self.dirs {
                 dirs.delete_path(filename)?;
             }
         }
         if old_state == EntryState::Unknown {
             if let Some(ref mut all_dirs) = self.all_dirs {
                 all_dirs.add_path(filename);
             }
         }
 
         if let Some(ref mut file_fold_map) = self.file_fold_map {
             file_fold_map.remove(&filename.to_ascii_uppercase());
         }
         self.state_map.insert(
             filename.to_owned(),
             DirstateEntry {
                 state: EntryState::Removed,
                 mode: 0,
                 size,
                 mtime: 0,
             },
         );
         self.non_normal_set.insert(filename.to_owned());
         Ok(())
     }
 
     /// Remove a file from the dirstate.
     /// Returns `true` if the file was previously recorded.
     pub fn drop_file(
         &mut self,
         filename: &[u8],
         old_state: EntryState,
     ) -> Result<bool, DirstateMapError> {
         let exists = self.state_map.remove(filename).is_some();
 
         if exists {
             if old_state != EntryState::Removed {
                 if let Some(ref mut dirs) = self.dirs {
                     dirs.delete_path(filename)?;
                 }
             }
             if let Some(ref mut all_dirs) = self.all_dirs {
                 all_dirs.delete_path(filename)?;
             }
         }
         if let Some(ref mut file_fold_map) = self.file_fold_map {
             file_fold_map.remove(&filename.to_ascii_uppercase());
         }
         self.non_normal_set.remove(filename);
 
         Ok(exists)
     }
 
     pub fn clear_ambiguous_times(
         &mut self,
         filenames: Vec<Vec<u8>>,
         now: i32,
     ) {
         for filename in filenames {
             let mut changed = false;
             self.state_map
                 .entry(filename.to_owned())
                 .and_modify(|entry| {
                     if entry.state == EntryState::Normal && entry.mtime == now
                     {
                         changed = true;
                         *entry = DirstateEntry {
                             mtime: MTIME_UNSET,
                             ..*entry
                         };
                     }
                 });
             if changed {
                 self.non_normal_set.insert(filename.to_owned());
             }
         }
     }
 
     pub fn non_normal_other_parent_entries(
         &self,
     ) -> (HashSet<Vec<u8>>, HashSet<Vec<u8>>) {
         let mut non_normal = HashSet::new();
         let mut other_parent = HashSet::new();
 
         for (
             filename,
             DirstateEntry {
                 state, size, mtime, ..
             },
         ) in self.state_map.iter()
         {
             if *state != EntryState::Normal || *mtime == MTIME_UNSET {
                 non_normal.insert(filename.to_owned());
             }
             if *state == EntryState::Normal && *size == SIZE_DIRTY {
                 other_parent.insert(filename.to_owned());
             }
         }
 
         (non_normal, other_parent)
     }
 
     /// Both of these setters and their uses appear to be the simplest way to
     /// emulate a Python lazy property, but it is ugly and unidiomatic.
     /// TODO One day, rewriting this struct using the typestate might be a
     /// good idea.
     pub fn set_all_dirs(&mut self) {
         if self.all_dirs.is_none() {
             self.all_dirs = Some(DirsMultiset::new(
                 DirsIterable::Dirstate(&self.state_map),
                 None,
             ));
         }
     }
 
     pub fn set_dirs(&mut self) {
         if self.dirs.is_none() {
             self.dirs = Some(DirsMultiset::new(
                 DirsIterable::Dirstate(&self.state_map),
                 Some(EntryState::Removed),
             ));
         }
     }
 
     pub fn has_tracked_dir(&mut self, directory: &[u8]) -> bool {
         self.set_dirs();
         self.dirs.as_ref().unwrap().contains(directory)
     }
 
     pub fn has_dir(&mut self, directory: &[u8]) -> bool {
         self.set_all_dirs();
         self.all_dirs.as_ref().unwrap().contains(directory)
     }
 
     pub fn parents(
         &mut self,
         file_contents: &[u8],
     ) -> Result<DirstateParents, DirstateError> {
         if let Some(ref parents) = self.parents {
             return Ok(parents.clone());
         }
         let parents;
         if file_contents.len() == PARENT_SIZE * 2 {
             parents = DirstateParents {
-                p1: copy_into_array(&file_contents[..PARENT_SIZE]),
-                p2: copy_into_array(
-                    &file_contents[PARENT_SIZE..PARENT_SIZE * 2],
-                ),
+                p1: file_contents[..PARENT_SIZE].try_into().unwrap(),
+                p2: file_contents[PARENT_SIZE..PARENT_SIZE * 2]
+                    .try_into()
+                    .unwrap(),
             };
         } else if file_contents.is_empty() {
             parents = DirstateParents {
                 p1: NULL_ID,
                 p2: NULL_ID,
             };
         } else {
             return Err(DirstateError::Parse(DirstateParseError::Damaged));
         }
 
         self.parents = Some(parents.to_owned());
         Ok(parents.clone())
     }
 
     pub fn set_parents(&mut self, parents: DirstateParents) {
         self.parents = Some(parents.clone());
         self.dirty_parents = true;
     }
 
     pub fn read(
         &mut self,
         file_contents: &[u8],
     ) -> Result<Option<DirstateParents>, DirstateError> {
         if file_contents.is_empty() {
             return Ok(None);
         }
 
         let parents = parse_dirstate(
             &mut self.state_map,
             &mut self.copy_map,
             file_contents,
         )?;
 
         if !self.dirty_parents {
             self.set_parents(parents.to_owned());
         }
 
         Ok(Some(parents))
     }
 
     pub fn pack(
         &mut self,
         parents: DirstateParents,
         now: Duration,
     ) -> Result<Vec<u8>, DirstateError> {
         let packed =
             pack_dirstate(&mut self.state_map, &self.copy_map, parents, now)?;
 
         self.dirty_parents = false;
 
         let result = self.non_normal_other_parent_entries();
         self.non_normal_set = result.0;
         self.other_parent_set = result.1;
         Ok(packed)
     }
 
     pub fn build_file_fold_map(&mut self) -> FileFoldMap {
         if let Some(ref file_fold_map) = self.file_fold_map {
             return file_fold_map.to_owned();
         }
         let mut new_file_fold_map = FileFoldMap::new();
         for (filename, DirstateEntry { state, .. }) in self.state_map.borrow()
         {
             if *state == EntryState::Removed {
                 new_file_fold_map.insert(
                     filename.to_ascii_uppercase().to_owned(),
                     filename.to_owned(),
                 );
             }
         }
         self.file_fold_map = Some(new_file_fold_map);
         self.file_fold_map.to_owned().unwrap()
     }
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
 
     #[test]
     fn test_dirs_multiset() {
         let mut map = DirstateMap::new();
         assert!(map.dirs.is_none());
         assert!(map.all_dirs.is_none());
 
         assert_eq!(false, map.has_dir(b"nope"));
         assert!(map.all_dirs.is_some());
         assert!(map.dirs.is_none());
 
         assert_eq!(false, map.has_tracked_dir(b"nope"));
         assert!(map.dirs.is_some());
     }
 
     #[test]
     fn test_add_file() {
         let mut map = DirstateMap::new();
 
         assert_eq!(0, map.len());
 
         map.add_file(
             b"meh",
             EntryState::Normal,
             DirstateEntry {
                 state: EntryState::Normal,
                 mode: 1337,
                 mtime: 1337,
                 size: 1337,
             },
         );
 
         assert_eq!(1, map.len());
         assert_eq!(0, map.non_normal_set.len());
         assert_eq!(0, map.other_parent_set.len());
     }
 
     #[test]
     fn test_non_normal_other_parent_entries() {
         let map: DirstateMap = [
             (b"f1", (EntryState::Removed, 1337, 1337, 1337)),
             (b"f2", (EntryState::Normal, 1337, 1337, -1)),
             (b"f3", (EntryState::Normal, 1337, 1337, 1337)),
             (b"f4", (EntryState::Normal, 1337, -2, 1337)),
             (b"f5", (EntryState::Added, 1337, 1337, 1337)),
             (b"f6", (EntryState::Added, 1337, 1337, -1)),
             (b"f7", (EntryState::Merged, 1337, 1337, -1)),
             (b"f8", (EntryState::Merged, 1337, 1337, 1337)),
             (b"f9", (EntryState::Merged, 1337, -2, 1337)),
             (b"fa", (EntryState::Added, 1337, -2, 1337)),
             (b"fb", (EntryState::Removed, 1337, -2, 1337)),
         ]
         .iter()
         .map(|(fname, (state, mode, size, mtime))| {
             (
                 fname.to_vec(),
                 DirstateEntry {
                     state: *state,
                     mode: *mode,
                     size: *size,
                     mtime: *mtime,
                 },
             )
         })
         .collect();
 
         let non_normal = [
             b"f1", b"f2", b"f5", b"f6", b"f7", b"f8", b"f9", b"fa", b"fb",
         ]
         .iter()
         .map(|x| x.to_vec())
         .collect();
 
         let mut other_parent = HashSet::new();
         other_parent.insert(b"f4".to_vec());
 
         assert_eq!(
             (non_normal, other_parent),
             map.non_normal_other_parent_entries()
         );
     }
 }

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

@@ -1,415 +1,414
 // 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]),
+        p1: contents[..PARENT_SIZE].try_into().unwrap(),
+        p2: contents[PARENT_SIZE..curr_pos].try_into().unwrap(),
     };
 
     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(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 (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(),
                 DirstateEntry {
                     mtime: new_mtime,
                     ..*entry
                 },
             ));
         }
 
         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)
         )
     }
 }

rust/hg-core/src/utils.rs

@@ -1,101 +1,84
 // utils module
 //
 // 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.
 
 //! Contains useful functions, traits, structs, etc. for use in core.
 
 pub mod files;
 
-use std::convert::AsMut;
-
-/// Takes a slice and copies it into an array.
-///
-/// # Panics
-///
-/// Will panic if the slice and target array don't have the same length.
-pub fn copy_into_array<A, T>(slice: &[T]) -> A
-where
-    A: Sized + Default + AsMut<[T]>,
-    T: Copy,
-{
-    let mut a = Default::default();
-    <A as AsMut<[T]>>::as_mut(&mut a).copy_from_slice(slice);
-    a
-}
-
 /// Replaces the `from` slice with the `to` slice inside the `buf` slice.
 ///
 /// # Examples
 ///
 /// ```
 /// use crate::hg::utils::replace_slice;
 /// let mut line = b"I hate writing tests!".to_vec();
 /// replace_slice(&mut line, b"hate", b"love");
 /// assert_eq!(
 ///     line,
 ///     b"I love writing tests!".to_vec()
 ///);
 ///
 /// ```
 pub fn replace_slice<T>(buf: &mut [T], from: &[T], to: &[T])
 where
     T: Clone + PartialEq,
 {
     if buf.len() < from.len() || from.len() != to.len() {
         return;
     }
     for i in 0..=buf.len() - from.len() {
         if buf[i..].starts_with(from) {
             buf[i..(i + from.len())].clone_from_slice(to);
         }
     }
 }
 
 pub trait SliceExt {
     fn trim_end(&self) -> &Self;
     fn trim_start(&self) -> &Self;
     fn trim(&self) -> &Self;
 }
 
 fn is_not_whitespace(c: &u8) -> bool {
     !(*c as char).is_whitespace()
 }
 
 impl SliceExt for [u8] {
     fn trim_end(&self) -> &[u8] {
         if let Some(last) = self.iter().rposition(is_not_whitespace) {
             &self[..last + 1]
         } else {
             &[]
         }
     }
     fn trim_start(&self) -> &[u8] {
         if let Some(first) = self.iter().position(is_not_whitespace) {
             &self[first..]
         } else {
             &[]
         }
     }
 
     /// ```
     /// use hg::utils::SliceExt;
     /// assert_eq!(
     ///     b"  to trim  ".trim(),
     ///     b"to trim"
     /// );
     /// assert_eq!(
     ///     b"to trim  ".trim(),
     ///     b"to trim"
     /// );
     /// assert_eq!(
     ///     b"  to trim".trim(),
     ///     b"to trim"
     /// );
     /// ```
     fn trim(&self) -> &[u8] {
         self.trim_start().trim_end()
     }
 }

rust/hg-cpython/src/dirstate/dirstate_map.rs

@@ -1,508 +1,510
 // dirstate_map.rs
 //
 // 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.
 
 //! Bindings for the `hg::dirstate::dirstate_map` file provided by the
 //! `hg-core` package.
 
 use std::cell::RefCell;
 use std::convert::TryInto;
 use std::time::Duration;
 
 use cpython::{
     exc, ObjectProtocol, PyBool, PyBytes, PyClone, PyDict, PyErr, PyObject,
     PyResult, PyTuple, Python, PythonObject, ToPyObject,
 };
 use libc::c_char;
 
 use crate::{
     dirstate::copymap::{CopyMap, CopyMapItemsIterator, CopyMapKeysIterator},
     dirstate::{decapsule_make_dirstate_tuple, dirs_multiset::Dirs},
     ref_sharing::PySharedState,
 };
 use hg::{
-    utils::copy_into_array, DirsIterable, DirsMultiset, DirstateEntry,
+    DirsIterable, DirsMultiset, DirstateEntry,
     DirstateMap as RustDirstateMap, DirstateParents, DirstateParseError,
     EntryState,
 };
 
 // TODO
 //     This object needs to share references to multiple members of its Rust
 //     inner struct, namely `copy_map`, `dirs` and `all_dirs`.
 //     Right now `CopyMap` is done, but it needs to have an explicit reference
 //     to `RustDirstateMap` which itself needs to have an encapsulation for
 //     every method in `CopyMap` (copymapcopy, etc.).
 //     This is ugly and hard to maintain.
 //     The same logic applies to `dirs` and `all_dirs`, however the `Dirs`
 //     `py_class!` is already implemented and does not mention
 //     `RustDirstateMap`, rightfully so.
 //     All attributes also have to have a separate refcount data attribute for
 //     leaks, with all methods that go along for reference sharing.
 py_class!(pub class DirstateMap |py| {
     data inner: RefCell<RustDirstateMap>;
     data py_shared_state: PySharedState;
 
     def __new__(_cls, _root: PyObject) -> PyResult<Self> {
         let inner = RustDirstateMap::default();
         Self::create_instance(
             py,
             RefCell::new(inner),
             PySharedState::default()
         )
     }
 
     def clear(&self) -> PyResult<PyObject> {
         self.borrow_mut(py)?.clear();
         Ok(py.None())
     }
 
     def get(
         &self,
         key: PyObject,
         default: Option<PyObject> = None
     ) -> PyResult<Option<PyObject>> {
         let key = key.extract::<PyBytes>(py)?;
         match self.inner(py).borrow().get(key.data(py)) {
             Some(entry) => {
                 // Explicitly go through u8 first, then cast to
                 // platform-specific `c_char`.
                 let state: u8 = entry.state.into();
                 Ok(Some(decapsule_make_dirstate_tuple(py)?(
                         state as c_char,
                         entry.mode,
                         entry.size,
                         entry.mtime,
                     )))
             },
             None => Ok(default)
         }
     }
 
     def addfile(
         &self,
         f: PyObject,
         oldstate: PyObject,
         state: PyObject,
         mode: PyObject,
         size: PyObject,
         mtime: PyObject
     ) -> PyResult<PyObject> {
         self.borrow_mut(py)?.add_file(
             f.extract::<PyBytes>(py)?.data(py),
             oldstate.extract::<PyBytes>(py)?.data(py)[0]
                 .try_into()
                 .map_err(|e: DirstateParseError| {
                     PyErr::new::<exc::ValueError, _>(py, e.to_string())
                 })?,
             DirstateEntry {
                 state: state.extract::<PyBytes>(py)?.data(py)[0]
                     .try_into()
                     .map_err(|e: DirstateParseError| {
                         PyErr::new::<exc::ValueError, _>(py, e.to_string())
                     })?,
                 mode: mode.extract(py)?,
                 size: size.extract(py)?,
                 mtime: mtime.extract(py)?,
             },
         );
         Ok(py.None())
     }
 
     def removefile(
         &self,
         f: PyObject,
         oldstate: PyObject,
         size: PyObject
     ) -> PyResult<PyObject> {
         self.borrow_mut(py)?
             .remove_file(
                 f.extract::<PyBytes>(py)?.data(py),
                 oldstate.extract::<PyBytes>(py)?.data(py)[0]
                     .try_into()
                     .map_err(|e: DirstateParseError| {
                         PyErr::new::<exc::ValueError, _>(py, e.to_string())
                     })?,
                 size.extract(py)?,
             )
             .or_else(|_| {
                 Err(PyErr::new::<exc::OSError, _>(
                     py,
                     "Dirstate error".to_string(),
                 ))
             })?;
         Ok(py.None())
     }
 
     def dropfile(
         &self,
         f: PyObject,
         oldstate: PyObject
     ) -> PyResult<PyBool> {
         self.borrow_mut(py)?
             .drop_file(
                 f.extract::<PyBytes>(py)?.data(py),
                 oldstate.extract::<PyBytes>(py)?.data(py)[0]
                     .try_into()
                     .map_err(|e: DirstateParseError| {
                         PyErr::new::<exc::ValueError, _>(py, e.to_string())
                     })?,
             )
             .and_then(|b| Ok(b.to_py_object(py)))
             .or_else(|_| {
                 Err(PyErr::new::<exc::OSError, _>(
                     py,
                     "Dirstate error".to_string(),
                 ))
             })
     }
 
     def clearambiguoustimes(
         &self,
         files: PyObject,
         now: PyObject
     ) -> PyResult<PyObject> {
         let files: PyResult<Vec<Vec<u8>>> = files
             .iter(py)?
             .map(|filename| {
                 Ok(filename?.extract::<PyBytes>(py)?.data(py).to_owned())
             })
             .collect();
         self.inner(py)
             .borrow_mut()
             .clear_ambiguous_times(files?, now.extract(py)?);
         Ok(py.None())
     }
 
     // TODO share the reference
     def nonnormalentries(&self) -> PyResult<PyObject> {
         let (non_normal, other_parent) =
             self.inner(py).borrow().non_normal_other_parent_entries();
 
         let locals = PyDict::new(py);
         locals.set_item(
             py,
             "non_normal",
             non_normal
                 .iter()
                 .map(|v| PyBytes::new(py, &v))
                 .collect::<Vec<PyBytes>>()
                 .to_py_object(py),
         )?;
         locals.set_item(
             py,
             "other_parent",
             other_parent
                 .iter()
                 .map(|v| PyBytes::new(py, &v))
                 .collect::<Vec<PyBytes>>()
                 .to_py_object(py),
         )?;
 
         py.eval("set(non_normal), set(other_parent)", None, Some(&locals))
     }
 
     def hastrackeddir(&self, d: PyObject) -> PyResult<PyBool> {
         let d = d.extract::<PyBytes>(py)?;
         Ok(self
             .inner(py)
             .borrow_mut()
             .has_tracked_dir(d.data(py))
             .to_py_object(py))
     }
 
     def hasdir(&self, d: PyObject) -> PyResult<PyBool> {
         let d = d.extract::<PyBytes>(py)?;
         Ok(self
             .inner(py)
             .borrow_mut()
             .has_dir(d.data(py))
             .to_py_object(py))
     }
 
     def parents(&self, st: PyObject) -> PyResult<PyTuple> {
         self.inner(py)
             .borrow_mut()
             .parents(st.extract::<PyBytes>(py)?.data(py))
             .and_then(|d| {
                 Ok((PyBytes::new(py, &d.p1), PyBytes::new(py, &d.p2))
                     .to_py_object(py))
             })
             .or_else(|_| {
                 Err(PyErr::new::<exc::OSError, _>(
                     py,
                     "Dirstate error".to_string(),
                 ))
             })
     }
 
     def setparents(&self, p1: PyObject, p2: PyObject) -> PyResult<PyObject> {
-        let p1 = copy_into_array(p1.extract::<PyBytes>(py)?.data(py));
-        let p2 = copy_into_array(p2.extract::<PyBytes>(py)?.data(py));
+        // TODO: don't panic; raise Python exception instead.
+        let p1 = p1.extract::<PyBytes>(py)?.data(py).try_into().unwrap();
+        let p2 = p2.extract::<PyBytes>(py)?.data(py).try_into().unwrap();
 
         self.inner(py)
             .borrow_mut()
             .set_parents(DirstateParents { p1, p2 });
         Ok(py.None())
     }
 
     def read(&self, st: PyObject) -> PyResult<Option<PyObject>> {
         match self
             .inner(py)
             .borrow_mut()
             .read(st.extract::<PyBytes>(py)?.data(py))
         {
             Ok(Some(parents)) => Ok(Some(
                 (PyBytes::new(py, &parents.p1), PyBytes::new(py, &parents.p2))
                     .to_py_object(py)
                     .into_object(),
             )),
             Ok(None) => Ok(Some(py.None())),
             Err(_) => Err(PyErr::new::<exc::OSError, _>(
                 py,
                 "Dirstate error".to_string(),
             )),
         }
     }
     def write(
         &self,
         p1: PyObject,
         p2: PyObject,
         now: PyObject
     ) -> PyResult<PyBytes> {
         let now = Duration::new(now.extract(py)?, 0);
         let parents = DirstateParents {
-            p1: copy_into_array(p1.extract::<PyBytes>(py)?.data(py)),
-            p2: copy_into_array(p2.extract::<PyBytes>(py)?.data(py)),
+            // TODO: don't panic; raise Python exception instead.
+            p1: p1.extract::<PyBytes>(py)?.data(py).try_into().unwrap(),
+            p2: p2.extract::<PyBytes>(py)?.data(py).try_into().unwrap(),
         };
 
         match self.borrow_mut(py)?.pack(parents, now) {
             Ok(packed) => Ok(PyBytes::new(py, &packed)),
             Err(_) => Err(PyErr::new::<exc::OSError, _>(
                 py,
                 "Dirstate error".to_string(),
             )),
         }
     }
 
     def filefoldmapasdict(&self) -> PyResult<PyDict> {
         let dict = PyDict::new(py);
         for (key, value) in
             self.borrow_mut(py)?.build_file_fold_map().iter()
         {
             dict.set_item(py, key, value)?;
         }
         Ok(dict)
     }
 
     def __len__(&self) -> PyResult<usize> {
         Ok(self.inner(py).borrow().len())
     }
 
     def __contains__(&self, key: PyObject) -> PyResult<bool> {
         let key = key.extract::<PyBytes>(py)?;
         Ok(self.inner(py).borrow().contains_key(key.data(py)))
     }
 
     def __getitem__(&self, key: PyObject) -> PyResult<PyObject> {
         let key = key.extract::<PyBytes>(py)?;
         let key = key.data(py);
         match self.inner(py).borrow().get(key) {
             Some(entry) => {
                 // Explicitly go through u8 first, then cast to
                 // platform-specific `c_char`.
                 let state: u8 = entry.state.into();
                 Ok(decapsule_make_dirstate_tuple(py)?(
                         state as c_char,
                         entry.mode,
                         entry.size,
                         entry.mtime,
                     ))
             },
             None => Err(PyErr::new::<exc::KeyError, _>(
                 py,
                 String::from_utf8_lossy(key),
             )),
         }
     }
 
     def keys(&self) -> PyResult<DirstateMapKeysIterator> {
         DirstateMapKeysIterator::from_inner(
             py,
             Some(DirstateMapLeakedRef::new(py, &self)),
             Box::new(self.leak_immutable(py)?.iter()),
         )
     }
 
     def items(&self) -> PyResult<DirstateMapItemsIterator> {
         DirstateMapItemsIterator::from_inner(
             py,
             Some(DirstateMapLeakedRef::new(py, &self)),
             Box::new(self.leak_immutable(py)?.iter()),
         )
     }
 
     def __iter__(&self) -> PyResult<DirstateMapKeysIterator> {
         DirstateMapKeysIterator::from_inner(
             py,
             Some(DirstateMapLeakedRef::new(py, &self)),
             Box::new(self.leak_immutable(py)?.iter()),
         )
     }
 
     def getdirs(&self) -> PyResult<Dirs> {
         // TODO don't copy, share the reference
         self.inner(py).borrow_mut().set_dirs();
         Dirs::from_inner(
             py,
             DirsMultiset::new(
                 DirsIterable::Dirstate(&self.inner(py).borrow()),
                 Some(EntryState::Removed),
             ),
         )
     }
     def getalldirs(&self) -> PyResult<Dirs> {
         // TODO don't copy, share the reference
         self.inner(py).borrow_mut().set_all_dirs();
         Dirs::from_inner(
             py,
             DirsMultiset::new(
                 DirsIterable::Dirstate(&self.inner(py).borrow()),
                 None,
             ),
         )
     }
 
     // TODO all copymap* methods, see docstring above
     def copymapcopy(&self) -> PyResult<PyDict> {
         let dict = PyDict::new(py);
         for (key, value) in self.inner(py).borrow().copy_map.iter() {
             dict.set_item(py, PyBytes::new(py, key), PyBytes::new(py, value))?;
         }
         Ok(dict)
     }
 
     def copymapgetitem(&self, key: PyObject) -> PyResult<PyBytes> {
         let key = key.extract::<PyBytes>(py)?;
         match self.inner(py).borrow().copy_map.get(key.data(py)) {
             Some(copy) => Ok(PyBytes::new(py, copy)),
             None => Err(PyErr::new::<exc::KeyError, _>(
                 py,
                 String::from_utf8_lossy(key.data(py)),
             )),
         }
     }
     def copymap(&self) -> PyResult<CopyMap> {
         CopyMap::from_inner(py, self.clone_ref(py))
     }
 
     def copymaplen(&self) -> PyResult<usize> {
         Ok(self.inner(py).borrow().copy_map.len())
     }
     def copymapcontains(&self, key: PyObject) -> PyResult<bool> {
         let key = key.extract::<PyBytes>(py)?;
         Ok(self.inner(py).borrow().copy_map.contains_key(key.data(py)))
     }
     def copymapget(
         &self,
         key: PyObject,
         default: Option<PyObject>
     ) -> PyResult<Option<PyObject>> {
         let key = key.extract::<PyBytes>(py)?;
         match self.inner(py).borrow().copy_map.get(key.data(py)) {
             Some(copy) => Ok(Some(PyBytes::new(py, copy).into_object())),
             None => Ok(default),
         }
     }
     def copymapsetitem(
         &self,
         key: PyObject,
         value: PyObject
     ) -> PyResult<PyObject> {
         let key = key.extract::<PyBytes>(py)?;
         let value = value.extract::<PyBytes>(py)?;
         self.inner(py)
             .borrow_mut()
             .copy_map
             .insert(key.data(py).to_vec(), value.data(py).to_vec());
         Ok(py.None())
     }
     def copymappop(
         &self,
         key: PyObject,
         default: Option<PyObject>
     ) -> PyResult<Option<PyObject>> {
         let key = key.extract::<PyBytes>(py)?;
         match self.inner(py).borrow_mut().copy_map.remove(key.data(py)) {
             Some(_) => Ok(None),
             None => Ok(default),
         }
     }
 
     def copymapiter(&self) -> PyResult<CopyMapKeysIterator> {
         CopyMapKeysIterator::from_inner(
             py,
             Some(DirstateMapLeakedRef::new(py, &self)),
             Box::new(self.leak_immutable(py)?.copy_map.iter()),
         )
     }
 
     def copymapitemsiter(&self) -> PyResult<CopyMapItemsIterator> {
         CopyMapItemsIterator::from_inner(
             py,
             Some(DirstateMapLeakedRef::new(py, &self)),
             Box::new(self.leak_immutable(py)?.copy_map.iter()),
         )
     }
 
 });
 
 impl DirstateMap {
     fn translate_key(
         py: Python,
         res: (&Vec<u8>, &DirstateEntry),
     ) -> PyResult<Option<PyBytes>> {
         Ok(Some(PyBytes::new(py, res.0)))
     }
     fn translate_key_value(
         py: Python,
         res: (&Vec<u8>, &DirstateEntry),
     ) -> PyResult<Option<(PyBytes, PyObject)>> {
         let (f, entry) = res;
 
         // Explicitly go through u8 first, then cast to
         // platform-specific `c_char`.
         let state: u8 = entry.state.into();
         Ok(Some((
             PyBytes::new(py, f),
             decapsule_make_dirstate_tuple(py)?(
                 state as c_char,
                 entry.mode,
                 entry.size,
                 entry.mtime,
             ),
         )))
     }
 }
 
 py_shared_ref!(DirstateMap, RustDirstateMap, inner, DirstateMapLeakedRef,);
 
 py_shared_mapping_iterator!(
     DirstateMapKeysIterator,
     DirstateMapLeakedRef,
     Vec<u8>,
     DirstateEntry,
     DirstateMap::translate_key,
     Option<PyBytes>
 );
 
 py_shared_mapping_iterator!(
     DirstateMapItemsIterator,
     DirstateMapLeakedRef,
     Vec<u8>,
     DirstateEntry,
     DirstateMap::translate_key_value,
     Option<(PyBytes, PyObject)>
 );

rust/hg-cpython/src/parsers.rs

@@ -1,207 +1,208
 // parsers.rs
 //
 // 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.
 
 //! Bindings for the `hg::dirstate::parsers` module provided by the
 //! `hg-core` package.
 //!
 //! From Python, this will be seen as `mercurial.rustext.parsers`
 //!
 use cpython::{
     exc, PyBytes, PyDict, PyErr, PyInt, PyModule, PyResult, PyTuple, Python,
     PythonObject, ToPyObject,
 };
 use hg::{
-    pack_dirstate, parse_dirstate, utils::copy_into_array, DirstateEntry,
+    pack_dirstate, parse_dirstate, DirstateEntry,
     DirstatePackError, DirstateParents, DirstateParseError, PARENT_SIZE,
 };
 use std::collections::HashMap;
+use std::convert::TryInto;
 
 use libc::c_char;
 
 use crate::dirstate::{decapsule_make_dirstate_tuple, extract_dirstate};
 use std::time::Duration;
 
 fn parse_dirstate_wrapper(
     py: Python,
     dmap: PyDict,
     copymap: PyDict,
     st: PyBytes,
 ) -> PyResult<PyTuple> {
     let mut dirstate_map = HashMap::new();
     let mut copies = HashMap::new();
 
     match parse_dirstate(&mut dirstate_map, &mut copies, st.data(py)) {
         Ok(parents) => {
             for (filename, entry) in dirstate_map {
                 // Explicitly go through u8 first, then cast to
                 // platform-specific `c_char` because Into<u8> has a specific
                 // implementation while `as c_char` would just do a naive enum
                 // cast.
                 let state: u8 = entry.state.into();
 
                 dmap.set_item(
                     py,
                     PyBytes::new(py, &filename),
                     decapsule_make_dirstate_tuple(py)?(
                         state as c_char,
                         entry.mode,
                         entry.size,
                         entry.mtime,
                     ),
                 )?;
             }
             for (path, copy_path) in copies {
                 copymap.set_item(
                     py,
                     PyBytes::new(py, &path),
                     PyBytes::new(py, &copy_path),
                 )?;
             }
             Ok(
                 (PyBytes::new(py, &parents.p1), PyBytes::new(py, &parents.p2))
                     .to_py_object(py),
             )
         }
         Err(e) => Err(PyErr::new::<exc::ValueError, _>(
             py,
             match e {
                 DirstateParseError::TooLittleData => {
                     "too little data for parents".to_string()
                 }
                 DirstateParseError::Overflow => {
                     "overflow in dirstate".to_string()
                 }
                 DirstateParseError::CorruptedEntry(e) => e,
                 DirstateParseError::Damaged => {
                     "dirstate appears to be damaged".to_string()
                 }
             },
         )),
     }
 }
 
 fn pack_dirstate_wrapper(
     py: Python,
     dmap: PyDict,
     copymap: PyDict,
     pl: PyTuple,
     now: PyInt,
 ) -> PyResult<PyBytes> {
     let p1 = pl.get_item(py, 0).extract::<PyBytes>(py)?;
     let p1: &[u8] = p1.data(py);
     let p2 = pl.get_item(py, 1).extract::<PyBytes>(py)?;
     let p2: &[u8] = p2.data(py);
 
     let mut dirstate_map = extract_dirstate(py, &dmap)?;
 
     let copies: Result<HashMap<Vec<u8>, Vec<u8>>, PyErr> = copymap
         .items(py)
         .iter()
         .map(|(key, value)| {
             Ok((
                 key.extract::<PyBytes>(py)?.data(py).to_owned(),
                 value.extract::<PyBytes>(py)?.data(py).to_owned(),
             ))
         })
         .collect();
 
     if p1.len() != PARENT_SIZE || p2.len() != PARENT_SIZE {
         return Err(PyErr::new::<exc::ValueError, _>(
             py,
             "expected a 20-byte hash".to_string(),
         ));
     }
 
     match pack_dirstate(
         &mut dirstate_map,
         &copies?,
         DirstateParents {
-            p1: copy_into_array(&p1),
-            p2: copy_into_array(&p2),
+            p1: p1.try_into().unwrap(),
+            p2: p2.try_into().unwrap(),
         },
         Duration::from_secs(now.as_object().extract::<u64>(py)?),
     ) {
         Ok(packed) => {
             for (
                 filename,
                 DirstateEntry {
                     state,
                     mode,
                     size,
                     mtime,
                 },
             ) in dirstate_map
             {
                 // Explicitly go through u8 first, then cast to
                 // platform-specific `c_char` because Into<u8> has a specific
                 // implementation while `as c_char` would just do a naive enum
                 // cast.
                 let state: u8 = state.into();
                 dmap.set_item(
                     py,
                     PyBytes::new(py, &filename[..]),
                     decapsule_make_dirstate_tuple(py)?(
                         state as c_char,
                         mode,
                         size,
                         mtime,
                     ),
                 )?;
             }
             Ok(PyBytes::new(py, &packed))
         }
         Err(error) => Err(PyErr::new::<exc::ValueError, _>(
             py,
             match error {
                 DirstatePackError::CorruptedParent => {
                     "expected a 20-byte hash".to_string()
                 }
                 DirstatePackError::CorruptedEntry(e) => e,
                 DirstatePackError::BadSize(expected, actual) => {
                     format!("bad dirstate size: {} != {}", actual, expected)
                 }
             },
         )),
     }
 }
 
 /// Create the module, with `__package__` given from parent
 pub fn init_parsers_module(py: Python, package: &str) -> PyResult<PyModule> {
     let dotted_name = &format!("{}.parsers", package);
     let m = PyModule::new(py, dotted_name)?;
 
     m.add(py, "__package__", package)?;
     m.add(py, "__doc__", "Parsers - Rust implementation")?;
 
     m.add(
         py,
         "parse_dirstate",
         py_fn!(
             py,
             parse_dirstate_wrapper(dmap: PyDict, copymap: PyDict, st: PyBytes)
         ),
     )?;
     m.add(
         py,
         "pack_dirstate",
         py_fn!(
             py,
             pack_dirstate_wrapper(
                 dmap: PyDict,
                 copymap: PyDict,
                 pl: PyTuple,
                 now: PyInt
             )
         ),
     )?;
 
     let sys = PyModule::import(py, "sys")?;
     let sys_modules: PyDict = sys.get(py, "modules")?.extract(py)?;
     sys_modules.set_item(py, dotted_name, &m)?;
 
     Ok(m)
 }