dirstate-v2: Only convert from SystemTime to Timestamp and not back

Converting from Timestamp back to SystemTime was only used for equality
comparison, but this can also be done on Timestamp values.

Differential Revision: https://phab.mercurial-scm.org/D11631

rust/hg-core/src/dirstate_tree/on_disk.rs

@@ -1,733 +1,721 b''
 //! The "version 2" disk representation of the dirstate
 //!
 //! See `mercurial/helptext/internals/dirstate-v2.txt`
 
 use crate::dirstate_tree::dirstate_map::{self, DirstateMap, NodeRef};
 use crate::dirstate_tree::path_with_basename::WithBasename;
 use crate::errors::HgError;
 use crate::utils::hg_path::HgPath;
 use crate::DirstateEntry;
 use crate::DirstateError;
 use crate::DirstateParents;
 use bitflags::bitflags;
 use bytes_cast::unaligned::{I32Be, I64Be, U16Be, U32Be};
 use bytes_cast::BytesCast;
 use format_bytes::format_bytes;
 use std::borrow::Cow;
 use std::convert::{TryFrom, TryInto};
-use std::time::{Duration, SystemTime, UNIX_EPOCH};
+use std::time::{SystemTime, UNIX_EPOCH};
 
 /// Added at the start of `.hg/dirstate` when the "v2" format is used.
 /// This a redundant sanity check more than an actual "magic number" since
 /// `.hg/requires` already governs which format should be used.
 pub const V2_FORMAT_MARKER: &[u8; 12] = b"dirstate-v2\n";
 
 /// Keep space for 256-bit hashes
 const STORED_NODE_ID_BYTES: usize = 32;
 
 /// … even though only 160 bits are used for now, with SHA-1
 const USED_NODE_ID_BYTES: usize = 20;
 
 pub(super) const IGNORE_PATTERNS_HASH_LEN: usize = 20;
 pub(super) type IgnorePatternsHash = [u8; IGNORE_PATTERNS_HASH_LEN];
 
 /// Must match the constant of the same name in
 /// `mercurial/dirstateutils/docket.py`
 const TREE_METADATA_SIZE: usize = 44;
 
 /// Make sure that size-affecting changes are made knowingly
 #[allow(unused)]
 fn static_assert_size_of() {
     let _ = std::mem::transmute::<TreeMetadata, [u8; TREE_METADATA_SIZE]>;
     let _ = std::mem::transmute::<DocketHeader, [u8; TREE_METADATA_SIZE + 81]>;
     let _ = std::mem::transmute::<Node, [u8; 43]>;
 }
 
 // Must match `HEADER` in `mercurial/dirstateutils/docket.py`
 #[derive(BytesCast)]
 #[repr(C)]
 struct DocketHeader {
     marker: [u8; V2_FORMAT_MARKER.len()],
     parent_1: [u8; STORED_NODE_ID_BYTES],
     parent_2: [u8; STORED_NODE_ID_BYTES],
 
     metadata: TreeMetadata,
 
     /// Counted in bytes
     data_size: Size,
 
     uuid_size: u8,
 }
 
 pub struct Docket<'on_disk> {
     header: &'on_disk DocketHeader,
     uuid: &'on_disk [u8],
 }
 
 /// Fields are documented in the *Tree metadata in the docket file*
 /// section of `mercurial/helptext/internals/dirstate-v2.txt`
 #[derive(BytesCast)]
 #[repr(C)]
 struct TreeMetadata {
     root_nodes: ChildNodes,
     nodes_with_entry_count: Size,
     nodes_with_copy_source_count: Size,
     unreachable_bytes: Size,
     unused: [u8; 4],
 
     /// See *Optional hash of ignore patterns* section of
     /// `mercurial/helptext/internals/dirstate-v2.txt`
     ignore_patterns_hash: IgnorePatternsHash,
 }
 
 /// Fields are documented in the *The data file format*
 /// section of `mercurial/helptext/internals/dirstate-v2.txt`
 #[derive(BytesCast)]
 #[repr(C)]
 pub(super) struct Node {
     full_path: PathSlice,
 
     /// In bytes from `self.full_path.start`
     base_name_start: PathSize,
 
     copy_source: OptPathSlice,
     children: ChildNodes,
     pub(super) descendants_with_entry_count: Size,
     pub(super) tracked_descendants_count: Size,
     flags: Flags,
     data: Entry,
 }
 
 bitflags! {
     #[derive(BytesCast)]
     #[repr(C)]
     struct Flags: u8 {
         const WDIR_TRACKED = 1 << 0;
         const P1_TRACKED = 1 << 1;
         const P2_INFO = 1 << 2;
         const HAS_MODE_AND_SIZE = 1 << 3;
         const HAS_MTIME = 1 << 4;
     }
 }
 
 #[derive(BytesCast, Copy, Clone, Debug)]
 #[repr(C)]
 struct Entry {
     mode: I32Be,
     size: I32Be,
     mtime: I32Be,
 }
 
 /// Duration since the Unix epoch
 #[derive(BytesCast, Copy, Clone, PartialEq)]
 #[repr(C)]
 pub(super) struct Timestamp {
     seconds: I64Be,
 
     /// In `0 .. 1_000_000_000`.
     ///
     /// This timestamp is later or earlier than `(seconds, 0)` by this many
     /// nanoseconds, if `seconds` is non-negative or negative, respectively.
     nanoseconds: U32Be,
 }
 
 /// Counted in bytes from the start of the file
 ///
 /// NOTE: not supporting `.hg/dirstate` files larger than 4 GiB.
 type Offset = U32Be;
 
 /// Counted in number of items
 ///
 /// NOTE: we choose not to support counting more than 4 billion nodes anywhere.
 type Size = U32Be;
 
 /// Counted in bytes
 ///
 /// NOTE: we choose not to support file names/paths longer than 64 KiB.
 type PathSize = U16Be;
 
 /// A contiguous sequence of `len` times `Node`, representing the child nodes
 /// of either some other node or of the repository root.
 ///
 /// Always sorted by ascending `full_path`, to allow binary search.
 /// Since nodes with the same parent nodes also have the same parent path,
 /// only the `base_name`s need to be compared during binary search.
 #[derive(BytesCast, Copy, Clone)]
 #[repr(C)]
 struct ChildNodes {
     start: Offset,
     len: Size,
 }
 
 /// A `HgPath` of `len` bytes
 #[derive(BytesCast, Copy, Clone)]
 #[repr(C)]
 struct PathSlice {
     start: Offset,
     len: PathSize,
 }
 
 /// Either nothing if `start == 0`, or a `HgPath` of `len` bytes
 type OptPathSlice = PathSlice;
 
 /// Unexpected file format found in `.hg/dirstate` with the "v2" format.
 ///
 /// This should only happen if Mercurial is buggy or a repository is corrupted.
 #[derive(Debug)]
 pub struct DirstateV2ParseError;
 
 impl From<DirstateV2ParseError> for HgError {
     fn from(_: DirstateV2ParseError) -> Self {
         HgError::corrupted("dirstate-v2 parse error")
     }
 }
 
 impl From<DirstateV2ParseError> for crate::DirstateError {
     fn from(error: DirstateV2ParseError) -> Self {
         HgError::from(error).into()
     }
 }
 
 impl<'on_disk> Docket<'on_disk> {
     pub fn parents(&self) -> DirstateParents {
         use crate::Node;
         let p1 = Node::try_from(&self.header.parent_1[..USED_NODE_ID_BYTES])
             .unwrap()
             .clone();
         let p2 = Node::try_from(&self.header.parent_2[..USED_NODE_ID_BYTES])
             .unwrap()
             .clone();
         DirstateParents { p1, p2 }
     }
 
     pub fn tree_metadata(&self) -> &[u8] {
         self.header.metadata.as_bytes()
     }
 
     pub fn data_size(&self) -> usize {
         // This `unwrap` could only panic on a 16-bit CPU
         self.header.data_size.get().try_into().unwrap()
     }
 
     pub fn data_filename(&self) -> String {
         String::from_utf8(format_bytes!(b"dirstate.{}", self.uuid)).unwrap()
     }
 }
 
 pub fn read_docket(
     on_disk: &[u8],
 ) -> Result<Docket<'_>, DirstateV2ParseError> {
     let (header, uuid) =
         DocketHeader::from_bytes(on_disk).map_err(|_| DirstateV2ParseError)?;
     let uuid_size = header.uuid_size as usize;
     if header.marker == *V2_FORMAT_MARKER && uuid.len() == uuid_size {
         Ok(Docket { header, uuid })
     } else {
         Err(DirstateV2ParseError)
     }
 }
 
 pub(super) fn read<'on_disk>(
     on_disk: &'on_disk [u8],
     metadata: &[u8],
 ) -> Result<DirstateMap<'on_disk>, DirstateV2ParseError> {
     if on_disk.is_empty() {
         return Ok(DirstateMap::empty(on_disk));
     }
     let (meta, _) = TreeMetadata::from_bytes(metadata)
         .map_err(|_| DirstateV2ParseError)?;
     let dirstate_map = DirstateMap {
         on_disk,
         root: dirstate_map::ChildNodes::OnDisk(read_nodes(
             on_disk,
             meta.root_nodes,
         )?),
         nodes_with_entry_count: meta.nodes_with_entry_count.get(),
         nodes_with_copy_source_count: meta.nodes_with_copy_source_count.get(),
         ignore_patterns_hash: meta.ignore_patterns_hash,
         unreachable_bytes: meta.unreachable_bytes.get(),
     };
     Ok(dirstate_map)
 }
 
 impl Node {
     pub(super) fn full_path<'on_disk>(
         &self,
         on_disk: &'on_disk [u8],
     ) -> Result<&'on_disk HgPath, DirstateV2ParseError> {
         read_hg_path(on_disk, self.full_path)
     }
 
     pub(super) fn base_name_start<'on_disk>(
         &self,
     ) -> Result<usize, DirstateV2ParseError> {
         let start = self.base_name_start.get();
         if start < self.full_path.len.get() {
             let start = usize::try_from(start)
                 // u32 -> usize, could only panic on a 16-bit CPU
                 .expect("dirstate-v2 base_name_start out of bounds");
             Ok(start)
         } else {
             Err(DirstateV2ParseError)
         }
     }
 
     pub(super) fn base_name<'on_disk>(
         &self,
         on_disk: &'on_disk [u8],
     ) -> Result<&'on_disk HgPath, DirstateV2ParseError> {
         let full_path = self.full_path(on_disk)?;
         let base_name_start = self.base_name_start()?;
         Ok(HgPath::new(&full_path.as_bytes()[base_name_start..]))
     }
 
     pub(super) fn path<'on_disk>(
         &self,
         on_disk: &'on_disk [u8],
     ) -> Result<dirstate_map::NodeKey<'on_disk>, DirstateV2ParseError> {
         Ok(WithBasename::from_raw_parts(
             Cow::Borrowed(self.full_path(on_disk)?),
             self.base_name_start()?,
         ))
     }
 
     pub(super) fn has_copy_source<'on_disk>(&self) -> bool {
         self.copy_source.start.get() != 0
     }
 
     pub(super) fn copy_source<'on_disk>(
         &self,
         on_disk: &'on_disk [u8],
     ) -> Result<Option<&'on_disk HgPath>, DirstateV2ParseError> {
         Ok(if self.has_copy_source() {
             Some(read_hg_path(on_disk, self.copy_source)?)
         } else {
             None
         })
     }
 
     fn has_entry(&self) -> bool {
         self.flags.intersects(
             Flags::WDIR_TRACKED | Flags::P1_TRACKED | Flags::P2_INFO,
         )
     }
 
     pub(super) fn node_data(
         &self,
     ) -> Result<dirstate_map::NodeData, DirstateV2ParseError> {
         if self.has_entry() {
             Ok(dirstate_map::NodeData::Entry(self.assume_entry()))
         } else if let Some(&mtime) = self.cached_directory_mtime() {
             Ok(dirstate_map::NodeData::CachedDirectory { mtime })
         } else {
             Ok(dirstate_map::NodeData::None)
         }
     }
 
     pub(super) fn cached_directory_mtime(&self) -> Option<&Timestamp> {
         if self.flags.contains(Flags::HAS_MTIME) && !self.has_entry() {
             Some(self.data.as_timestamp())
         } else {
             None
         }
     }
 
     fn assume_entry(&self) -> DirstateEntry {
         // TODO: convert through raw bits instead?
         let wdir_tracked = self.flags.contains(Flags::WDIR_TRACKED);
         let p1_tracked = self.flags.contains(Flags::P1_TRACKED);
         let p2_info = self.flags.contains(Flags::P2_INFO);
         let mode_size = if self.flags.contains(Flags::HAS_MODE_AND_SIZE) {
             Some((self.data.mode.into(), self.data.size.into()))
         } else {
             None
         };
         let mtime = if self.flags.contains(Flags::HAS_MTIME) {
             Some(self.data.mtime.into())
         } else {
             None
         };
         DirstateEntry::from_v2_data(
             wdir_tracked,
             p1_tracked,
             p2_info,
             mode_size,
             mtime,
         )
     }
 
     pub(super) fn entry(
         &self,
     ) -> Result<Option<DirstateEntry>, DirstateV2ParseError> {
         if self.has_entry() {
             Ok(Some(self.assume_entry()))
         } else {
             Ok(None)
         }
     }
 
     pub(super) fn children<'on_disk>(
         &self,
         on_disk: &'on_disk [u8],
     ) -> Result<&'on_disk [Node], DirstateV2ParseError> {
         read_nodes(on_disk, self.children)
     }
 
     pub(super) fn to_in_memory_node<'on_disk>(
         &self,
         on_disk: &'on_disk [u8],
     ) -> Result<dirstate_map::Node<'on_disk>, DirstateV2ParseError> {
         Ok(dirstate_map::Node {
             children: dirstate_map::ChildNodes::OnDisk(
                 self.children(on_disk)?,
             ),
             copy_source: self.copy_source(on_disk)?.map(Cow::Borrowed),
             data: self.node_data()?,
             descendants_with_entry_count: self
                 .descendants_with_entry_count
                 .get(),
             tracked_descendants_count: self.tracked_descendants_count.get(),
         })
     }
 }
 
 impl Entry {
     fn from_dirstate_entry(entry: &DirstateEntry) -> (Flags, Self) {
         let (wdir_tracked, p1_tracked, p2_info, mode_size_opt, mtime_opt) =
             entry.v2_data();
         // TODO: convert throug raw flag bits instead?
         let mut flags = Flags::empty();
         flags.set(Flags::WDIR_TRACKED, wdir_tracked);
         flags.set(Flags::P1_TRACKED, p1_tracked);
         flags.set(Flags::P2_INFO, p2_info);
         let (mode, size, mtime);
         if let Some((m, s)) = mode_size_opt {
             mode = m;
             size = s;
             flags.insert(Flags::HAS_MODE_AND_SIZE)
         } else {
             mode = 0;
             size = 0;
         }
         if let Some(m) = mtime_opt {
             mtime = m;
             flags.insert(Flags::HAS_MTIME);
         } else {
             mtime = 0;
         }
         let raw_entry = Entry {
             mode: mode.into(),
             size: size.into(),
             mtime: mtime.into(),
         };
         (flags, raw_entry)
     }
 
     fn from_timestamp(timestamp: Timestamp) -> Self {
         // Safety: both types implement the `ByteCast` trait, so we could
         // safely use `as_bytes` and `from_bytes` to do this conversion. Using
         // `transmute` instead makes the compiler check that the two types
         // have the same size, which eliminates the error case of
         // `from_bytes`.
         unsafe { std::mem::transmute::<Timestamp, Entry>(timestamp) }
     }
 
     fn as_timestamp(&self) -> &Timestamp {
         // Safety: same as above in `from_timestamp`
         unsafe { &*(self as *const Entry as *const Timestamp) }
     }
 }
 
 impl Timestamp {
     pub fn seconds(&self) -> i64 {
         self.seconds.get()
     }
 }
 
 impl From<SystemTime> for Timestamp {
     fn from(system_time: SystemTime) -> Self {
         let (secs, nanos) = match system_time.duration_since(UNIX_EPOCH) {
             Ok(duration) => {
                 (duration.as_secs() as i64, duration.subsec_nanos())
             }
             Err(error) => {
                 let negative = error.duration();
                 (-(negative.as_secs() as i64), negative.subsec_nanos())
             }
         };
         Timestamp {
             seconds: secs.into(),
             nanoseconds: nanos.into(),
         }
     }
 }
 
-impl From<&'_ Timestamp> for SystemTime {
-    fn from(timestamp: &'_ Timestamp) -> Self {
-        let secs = timestamp.seconds.get();
-        let nanos = timestamp.nanoseconds.get();
-        if secs >= 0 {
-            UNIX_EPOCH + Duration::new(secs as u64, nanos)
-        } else {
-            UNIX_EPOCH - Duration::new((-secs) as u64, nanos)
-        }
-    }
-}
-
 fn read_hg_path(
     on_disk: &[u8],
     slice: PathSlice,
 ) -> Result<&HgPath, DirstateV2ParseError> {
     read_slice(on_disk, slice.start, slice.len.get()).map(HgPath::new)
 }
 
 fn read_nodes(
     on_disk: &[u8],
     slice: ChildNodes,
 ) -> Result<&[Node], DirstateV2ParseError> {
     read_slice(on_disk, slice.start, slice.len.get())
 }
 
 fn read_slice<T, Len>(
     on_disk: &[u8],
     start: Offset,
     len: Len,
 ) -> Result<&[T], DirstateV2ParseError>
 where
     T: BytesCast,
     Len: TryInto<usize>,
 {
     // Either `usize::MAX` would result in "out of bounds" error since a single
     // `&[u8]` cannot occupy the entire addess space.
     let start = start.get().try_into().unwrap_or(std::usize::MAX);
     let len = len.try_into().unwrap_or(std::usize::MAX);
     on_disk
         .get(start..)
         .and_then(|bytes| T::slice_from_bytes(bytes, len).ok())
         .map(|(slice, _rest)| slice)
         .ok_or_else(|| DirstateV2ParseError)
 }
 
 pub(crate) fn for_each_tracked_path<'on_disk>(
     on_disk: &'on_disk [u8],
     metadata: &[u8],
     mut f: impl FnMut(&'on_disk HgPath),
 ) -> Result<(), DirstateV2ParseError> {
     let (meta, _) = TreeMetadata::from_bytes(metadata)
         .map_err(|_| DirstateV2ParseError)?;
     fn recur<'on_disk>(
         on_disk: &'on_disk [u8],
         nodes: ChildNodes,
         f: &mut impl FnMut(&'on_disk HgPath),
     ) -> Result<(), DirstateV2ParseError> {
         for node in read_nodes(on_disk, nodes)? {
             if let Some(entry) = node.entry()? {
                 if entry.state().is_tracked() {
                     f(node.full_path(on_disk)?)
                 }
             }
             recur(on_disk, node.children, f)?
         }
         Ok(())
     }
     recur(on_disk, meta.root_nodes, &mut f)
 }
 
 /// Returns new data and metadata, together with whether that data should be
 /// appended to the existing data file whose content is at
 /// `dirstate_map.on_disk` (true), instead of written to a new data file
 /// (false).
 pub(super) fn write(
     dirstate_map: &mut DirstateMap,
     can_append: bool,
 ) -> Result<(Vec<u8>, Vec<u8>, bool), DirstateError> {
     let append = can_append && dirstate_map.write_should_append();
 
     // This ignores the space for paths, and for nodes without an entry.
     // TODO: better estimate? Skip the `Vec` and write to a file directly?
     let size_guess = std::mem::size_of::<Node>()
         * dirstate_map.nodes_with_entry_count as usize;
 
     let mut writer = Writer {
         dirstate_map,
         append,
         out: Vec::with_capacity(size_guess),
     };
 
     let root_nodes = writer.write_nodes(dirstate_map.root.as_ref())?;
 
     let meta = TreeMetadata {
         root_nodes,
         nodes_with_entry_count: dirstate_map.nodes_with_entry_count.into(),
         nodes_with_copy_source_count: dirstate_map
             .nodes_with_copy_source_count
             .into(),
         unreachable_bytes: dirstate_map.unreachable_bytes.into(),
         unused: [0; 4],
         ignore_patterns_hash: dirstate_map.ignore_patterns_hash,
     };
     Ok((writer.out, meta.as_bytes().to_vec(), append))
 }
 
 struct Writer<'dmap, 'on_disk> {
     dirstate_map: &'dmap DirstateMap<'on_disk>,
     append: bool,
     out: Vec<u8>,
 }
 
 impl Writer<'_, '_> {
     fn write_nodes(
         &mut self,
         nodes: dirstate_map::ChildNodesRef,
     ) -> Result<ChildNodes, DirstateError> {
         // Reuse already-written nodes if possible
         if self.append {
             if let dirstate_map::ChildNodesRef::OnDisk(nodes_slice) = nodes {
                 let start = self.on_disk_offset_of(nodes_slice).expect(
                     "dirstate-v2 OnDisk nodes not found within on_disk",
                 );
                 let len = child_nodes_len_from_usize(nodes_slice.len());
                 return Ok(ChildNodes { start, len });
             }
         }
 
         // `dirstate_map::ChildNodes::InMemory` contains a `HashMap` which has
         // undefined iteration order. Sort to enable binary search in the
         // written file.
         let nodes = nodes.sorted();
         let nodes_len = nodes.len();
 
         // First accumulate serialized nodes in a `Vec`
         let mut on_disk_nodes = Vec::with_capacity(nodes_len);
         for node in nodes {
             let children =
                 self.write_nodes(node.children(self.dirstate_map.on_disk)?)?;
             let full_path = node.full_path(self.dirstate_map.on_disk)?;
             let full_path = self.write_path(full_path.as_bytes());
             let copy_source = if let Some(source) =
                 node.copy_source(self.dirstate_map.on_disk)?
             {
                 self.write_path(source.as_bytes())
             } else {
                 PathSlice {
                     start: 0.into(),
                     len: 0.into(),
                 }
             };
             on_disk_nodes.push(match node {
                 NodeRef::InMemory(path, node) => {
                     let (flags, data) = match &node.data {
                         dirstate_map::NodeData::Entry(entry) => {
                             Entry::from_dirstate_entry(entry)
                         }
                         dirstate_map::NodeData::CachedDirectory { mtime } => {
                             (Flags::HAS_MTIME, Entry::from_timestamp(*mtime))
                         }
                         dirstate_map::NodeData::None => (
                             Flags::empty(),
                             Entry {
                                 mode: 0.into(),
                                 size: 0.into(),
                                 mtime: 0.into(),
                             },
                         ),
                     };
                     Node {
                         children,
                         copy_source,
                         full_path,
                         base_name_start: u16::try_from(path.base_name_start())
                             // Could only panic for paths over 64 KiB
                             .expect("dirstate-v2 path length overflow")
                             .into(),
                         descendants_with_entry_count: node
                             .descendants_with_entry_count
                             .into(),
                         tracked_descendants_count: node
                             .tracked_descendants_count
                             .into(),
                         flags,
                         data,
                     }
                 }
                 NodeRef::OnDisk(node) => Node {
                     children,
                     copy_source,
                     full_path,
                     ..*node
                 },
             })
         }
         // … so we can write them contiguously, after writing everything else
         // they refer to.
         let start = self.current_offset();
         let len = child_nodes_len_from_usize(nodes_len);
         self.out.extend(on_disk_nodes.as_bytes());
         Ok(ChildNodes { start, len })
     }
 
     /// If the given slice of items is within `on_disk`, returns its offset
     /// from the start of `on_disk`.
     fn on_disk_offset_of<T>(&self, slice: &[T]) -> Option<Offset>
     where
         T: BytesCast,
     {
         fn address_range(slice: &[u8]) -> std::ops::RangeInclusive<usize> {
             let start = slice.as_ptr() as usize;
             let end = start + slice.len();
             start..=end
         }
         let slice_addresses = address_range(slice.as_bytes());
         let on_disk_addresses = address_range(self.dirstate_map.on_disk);
         if on_disk_addresses.contains(slice_addresses.start())
             && on_disk_addresses.contains(slice_addresses.end())
         {
             let offset = slice_addresses.start() - on_disk_addresses.start();
             Some(offset_from_usize(offset))
         } else {
             None
         }
     }
 
     fn current_offset(&mut self) -> Offset {
         let mut offset = self.out.len();
         if self.append {
             offset += self.dirstate_map.on_disk.len()
         }
         offset_from_usize(offset)
     }
 
     fn write_path(&mut self, slice: &[u8]) -> PathSlice {
         let len = path_len_from_usize(slice.len());
         // Reuse an already-written path if possible
         if self.append {
             if let Some(start) = self.on_disk_offset_of(slice) {
                 return PathSlice { start, len };
             }
         }
         let start = self.current_offset();
         self.out.extend(slice.as_bytes());
         PathSlice { start, len }
     }
 }
 
 fn offset_from_usize(x: usize) -> Offset {
     u32::try_from(x)
         // Could only panic for a dirstate file larger than 4 GiB
         .expect("dirstate-v2 offset overflow")
         .into()
 }
 
 fn child_nodes_len_from_usize(x: usize) -> Size {
     u32::try_from(x)
         // Could only panic with over 4 billion nodes
         .expect("dirstate-v2 slice length overflow")
         .into()
 }
 
 fn path_len_from_usize(x: usize) -> PathSize {
     u16::try_from(x)
         // Could only panic for paths over 64 KiB
         .expect("dirstate-v2 path length overflow")
         .into()
 }

rust/hg-core/src/dirstate_tree/status.rs

@@ -1,753 +1,754 b''
 use crate::dirstate::status::IgnoreFnType;
 use crate::dirstate_tree::dirstate_map::BorrowedPath;
 use crate::dirstate_tree::dirstate_map::ChildNodesRef;
 use crate::dirstate_tree::dirstate_map::DirstateMap;
 use crate::dirstate_tree::dirstate_map::NodeData;
 use crate::dirstate_tree::dirstate_map::NodeRef;
 use crate::dirstate_tree::on_disk::DirstateV2ParseError;
 use crate::dirstate_tree::on_disk::Timestamp;
 use crate::matchers::get_ignore_function;
 use crate::matchers::Matcher;
 use crate::utils::files::get_bytes_from_os_string;
 use crate::utils::files::get_path_from_bytes;
 use crate::utils::hg_path::HgPath;
 use crate::BadMatch;
 use crate::DirstateStatus;
 use crate::EntryState;
 use crate::HgPathBuf;
 use crate::PatternFileWarning;
 use crate::StatusError;
 use crate::StatusOptions;
 use micro_timer::timed;
 use rayon::prelude::*;
 use sha1::{Digest, Sha1};
 use std::borrow::Cow;
 use std::io;
 use std::path::Path;
 use std::path::PathBuf;
 use std::sync::Mutex;
 use std::time::SystemTime;
 
 /// Returns the status of the working directory compared to its parent
 /// changeset.
 ///
 /// This algorithm is based on traversing the filesystem tree (`fs` in function
 /// and variable names) and dirstate tree at the same time. The core of this
 /// traversal is the recursive `traverse_fs_directory_and_dirstate` function
 /// and its use of `itertools::merge_join_by`. When reaching a path that only
 /// exists in one of the two trees, depending on information requested by
 /// `options` we may need to traverse the remaining subtree.
 #[timed]
 pub fn status<'tree, 'on_disk: 'tree>(
     dmap: &'tree mut DirstateMap<'on_disk>,
     matcher: &(dyn Matcher + Sync),
     root_dir: PathBuf,
     ignore_files: Vec<PathBuf>,
     options: StatusOptions,
 ) -> Result<(DirstateStatus<'on_disk>, Vec<PatternFileWarning>), StatusError> {
     let (ignore_fn, warnings, patterns_changed): (IgnoreFnType, _, _) =
         if options.list_ignored || options.list_unknown {
             let mut hasher = Sha1::new();
             let (ignore_fn, warnings) = get_ignore_function(
                 ignore_files,
                 &root_dir,
                 &mut |pattern_bytes| hasher.update(pattern_bytes),
             )?;
             let new_hash = *hasher.finalize().as_ref();
             let changed = new_hash != dmap.ignore_patterns_hash;
             dmap.ignore_patterns_hash = new_hash;
             (ignore_fn, warnings, Some(changed))
         } else {
             (Box::new(|&_| true), vec![], None)
         };
 
     let common = StatusCommon {
         dmap,
         options,
         matcher,
         ignore_fn,
         outcome: Default::default(),
         ignore_patterns_have_changed: patterns_changed,
         new_cachable_directories: Default::default(),
         outated_cached_directories: Default::default(),
         filesystem_time_at_status_start: filesystem_now(&root_dir).ok(),
     };
     let is_at_repo_root = true;
     let hg_path = &BorrowedPath::OnDisk(HgPath::new(""));
     let has_ignored_ancestor = false;
     let root_cached_mtime = None;
     let root_dir_metadata = None;
     // If the path we have for the repository root is a symlink, do follow it.
     // (As opposed to symlinks within the working directory which are not
     // followed, using `std::fs::symlink_metadata`.)
     common.traverse_fs_directory_and_dirstate(
         has_ignored_ancestor,
         dmap.root.as_ref(),
         hg_path,
         &root_dir,
         root_dir_metadata,
         root_cached_mtime,
         is_at_repo_root,
     )?;
     let mut outcome = common.outcome.into_inner().unwrap();
     let new_cachable = common.new_cachable_directories.into_inner().unwrap();
     let outdated = common.outated_cached_directories.into_inner().unwrap();
 
     outcome.dirty = common.ignore_patterns_have_changed == Some(true)
         || !outdated.is_empty()
         || !new_cachable.is_empty();
 
     // Remove outdated mtimes before adding new mtimes, in case a given
     // directory is both
     for path in &outdated {
         let node = dmap.get_or_insert(path)?;
         if let NodeData::CachedDirectory { .. } = &node.data {
             node.data = NodeData::None
         }
     }
     for (path, mtime) in &new_cachable {
         let node = dmap.get_or_insert(path)?;
         match &node.data {
             NodeData::Entry(_) => {} // Don’t overwrite an entry
             NodeData::CachedDirectory { .. } | NodeData::None => {
                 node.data = NodeData::CachedDirectory { mtime: *mtime }
             }
         }
     }
 
     Ok((outcome, warnings))
 }
 
 /// Bag of random things needed by various parts of the algorithm. Reduces the
 /// number of parameters passed to functions.
 struct StatusCommon<'a, 'tree, 'on_disk: 'tree> {
     dmap: &'tree DirstateMap<'on_disk>,
     options: StatusOptions,
     matcher: &'a (dyn Matcher + Sync),
     ignore_fn: IgnoreFnType<'a>,
     outcome: Mutex<DirstateStatus<'on_disk>>,
     new_cachable_directories: Mutex<Vec<(Cow<'on_disk, HgPath>, Timestamp)>>,
     outated_cached_directories: Mutex<Vec<Cow<'on_disk, HgPath>>>,
 
     /// Whether ignore files like `.hgignore` have changed since the previous
     /// time a `status()` call wrote their hash to the dirstate. `None` means
     /// we don’t know as this run doesn’t list either ignored or uknown files
     /// and therefore isn’t reading `.hgignore`.
     ignore_patterns_have_changed: Option<bool>,
 
     /// The current time at the start of the `status()` algorithm, as measured
     /// and possibly truncated by the filesystem.
     filesystem_time_at_status_start: Option<SystemTime>,
 }
 
 impl<'a, 'tree, 'on_disk> StatusCommon<'a, 'tree, 'on_disk> {
     fn read_dir(
         &self,
         hg_path: &HgPath,
         fs_path: &Path,
         is_at_repo_root: bool,
     ) -> Result<Vec<DirEntry>, ()> {
         DirEntry::read_dir(fs_path, is_at_repo_root)
             .map_err(|error| self.io_error(error, hg_path))
     }
 
     fn io_error(&self, error: std::io::Error, hg_path: &HgPath) {
         let errno = error.raw_os_error().expect("expected real OS error");
         self.outcome
             .lock()
             .unwrap()
             .bad
             .push((hg_path.to_owned().into(), BadMatch::OsError(errno)))
     }
 
     fn check_for_outdated_directory_cache(
         &self,
         dirstate_node: &NodeRef<'tree, 'on_disk>,
     ) -> Result<(), DirstateV2ParseError> {
         if self.ignore_patterns_have_changed == Some(true)
             && dirstate_node.cached_directory_mtime().is_some()
         {
             self.outated_cached_directories.lock().unwrap().push(
                 dirstate_node
                     .full_path_borrowed(self.dmap.on_disk)?
                     .detach_from_tree(),
             )
         }
         Ok(())
     }
 
     /// If this returns true, we can get accurate results by only using
     /// `symlink_metadata` for child nodes that exist in the dirstate and don’t
     /// need to call `read_dir`.
     fn can_skip_fs_readdir(
         &self,
         directory_metadata: Option<&std::fs::Metadata>,
         cached_directory_mtime: Option<&Timestamp>,
     ) -> bool {
         if !self.options.list_unknown && !self.options.list_ignored {
             // All states that we care about listing have corresponding
             // dirstate entries.
             // This happens for example with `hg status -mard`.
             return true;
         }
         if !self.options.list_ignored
             && self.ignore_patterns_have_changed == Some(false)
         {
             if let Some(cached_mtime) = cached_directory_mtime {
                 // The dirstate contains a cached mtime for this directory, set
                 // by a previous run of the `status` algorithm which found this
                 // directory eligible for `read_dir` caching.
                 if let Some(meta) = directory_metadata {
                     if let Ok(current_mtime) = meta.modified() {
-                        if current_mtime == cached_mtime.into() {
+                        let current_mtime = Timestamp::from(current_mtime);
+                        if current_mtime == *cached_mtime {
                             // The mtime of that directory has not changed
                             // since then, which means that the results of
                             // `read_dir` should also be unchanged.
                             return true;
                         }
                     }
                 }
             }
         }
         false
     }
 
     /// Returns whether all child entries of the filesystem directory have a
     /// corresponding dirstate node or are ignored.
     fn traverse_fs_directory_and_dirstate(
         &self,
         has_ignored_ancestor: bool,
         dirstate_nodes: ChildNodesRef<'tree, 'on_disk>,
         directory_hg_path: &BorrowedPath<'tree, 'on_disk>,
         directory_fs_path: &Path,
         directory_metadata: Option<&std::fs::Metadata>,
         cached_directory_mtime: Option<&Timestamp>,
         is_at_repo_root: bool,
     ) -> Result<bool, DirstateV2ParseError> {
         if self.can_skip_fs_readdir(directory_metadata, cached_directory_mtime)
         {
             dirstate_nodes
                 .par_iter()
                 .map(|dirstate_node| {
                     let fs_path = directory_fs_path.join(get_path_from_bytes(
                         dirstate_node.base_name(self.dmap.on_disk)?.as_bytes(),
                     ));
                     match std::fs::symlink_metadata(&fs_path) {
                         Ok(fs_metadata) => self.traverse_fs_and_dirstate(
                             &fs_path,
                             &fs_metadata,
                             dirstate_node,
                             has_ignored_ancestor,
                         ),
                         Err(e) if e.kind() == std::io::ErrorKind::NotFound => {
                             self.traverse_dirstate_only(dirstate_node)
                         }
                         Err(error) => {
                             let hg_path =
                                 dirstate_node.full_path(self.dmap.on_disk)?;
                             Ok(self.io_error(error, hg_path))
                         }
                     }
                 })
                 .collect::<Result<_, _>>()?;
 
             // We don’t know, so conservatively say this isn’t the case
             let children_all_have_dirstate_node_or_are_ignored = false;
 
             return Ok(children_all_have_dirstate_node_or_are_ignored);
         }
 
         let mut fs_entries = if let Ok(entries) = self.read_dir(
             directory_hg_path,
             directory_fs_path,
             is_at_repo_root,
         ) {
             entries
         } else {
             // Treat an unreadable directory (typically because of insufficient
             // permissions) like an empty directory. `self.read_dir` has
             // already called `self.io_error` so a warning will be emitted.
             Vec::new()
         };
 
         // `merge_join_by` requires both its input iterators to be sorted:
 
         let dirstate_nodes = dirstate_nodes.sorted();
         // `sort_unstable_by_key` doesn’t allow keys borrowing from the value:
         // https://github.com/rust-lang/rust/issues/34162
         fs_entries.sort_unstable_by(|e1, e2| e1.base_name.cmp(&e2.base_name));
 
         // Propagate here any error that would happen inside the comparison
         // callback below
         for dirstate_node in &dirstate_nodes {
             dirstate_node.base_name(self.dmap.on_disk)?;
         }
         itertools::merge_join_by(
             dirstate_nodes,
             &fs_entries,
             |dirstate_node, fs_entry| {
                 // This `unwrap` never panics because we already propagated
                 // those errors above
                 dirstate_node
                     .base_name(self.dmap.on_disk)
                     .unwrap()
                     .cmp(&fs_entry.base_name)
             },
         )
         .par_bridge()
         .map(|pair| {
             use itertools::EitherOrBoth::*;
             let has_dirstate_node_or_is_ignored;
             match pair {
                 Both(dirstate_node, fs_entry) => {
                     self.traverse_fs_and_dirstate(
                         &fs_entry.full_path,
                         &fs_entry.metadata,
                         dirstate_node,
                         has_ignored_ancestor,
                     )?;
                     has_dirstate_node_or_is_ignored = true
                 }
                 Left(dirstate_node) => {
                     self.traverse_dirstate_only(dirstate_node)?;
                     has_dirstate_node_or_is_ignored = true;
                 }
                 Right(fs_entry) => {
                     has_dirstate_node_or_is_ignored = self.traverse_fs_only(
                         has_ignored_ancestor,
                         directory_hg_path,
                         fs_entry,
                     )
                 }
             }
             Ok(has_dirstate_node_or_is_ignored)
         })
         .try_reduce(|| true, |a, b| Ok(a && b))
     }
 
     fn traverse_fs_and_dirstate(
         &self,
         fs_path: &Path,
         fs_metadata: &std::fs::Metadata,
         dirstate_node: NodeRef<'tree, 'on_disk>,
         has_ignored_ancestor: bool,
     ) -> Result<(), DirstateV2ParseError> {
         self.check_for_outdated_directory_cache(&dirstate_node)?;
         let hg_path = &dirstate_node.full_path_borrowed(self.dmap.on_disk)?;
         let file_type = fs_metadata.file_type();
         let file_or_symlink = file_type.is_file() || file_type.is_symlink();
         if !file_or_symlink {
             // If we previously had a file here, it was removed (with
             // `hg rm` or similar) or deleted before it could be
             // replaced by a directory or something else.
             self.mark_removed_or_deleted_if_file(
                 &hg_path,
                 dirstate_node.state()?,
             );
         }
         if file_type.is_dir() {
             if self.options.collect_traversed_dirs {
                 self.outcome
                     .lock()
                     .unwrap()
                     .traversed
                     .push(hg_path.detach_from_tree())
             }
             let is_ignored = has_ignored_ancestor || (self.ignore_fn)(hg_path);
             let is_at_repo_root = false;
             let children_all_have_dirstate_node_or_are_ignored = self
                 .traverse_fs_directory_and_dirstate(
                     is_ignored,
                     dirstate_node.children(self.dmap.on_disk)?,
                     hg_path,
                     fs_path,
                     Some(fs_metadata),
                     dirstate_node.cached_directory_mtime(),
                     is_at_repo_root,
                 )?;
             self.maybe_save_directory_mtime(
                 children_all_have_dirstate_node_or_are_ignored,
                 fs_metadata,
                 dirstate_node,
             )?
         } else {
             if file_or_symlink && self.matcher.matches(hg_path) {
                 if let Some(state) = dirstate_node.state()? {
                     match state {
                         EntryState::Added => self
                             .outcome
                             .lock()
                             .unwrap()
                             .added
                             .push(hg_path.detach_from_tree()),
                         EntryState::Removed => self
                             .outcome
                             .lock()
                             .unwrap()
                             .removed
                             .push(hg_path.detach_from_tree()),
                         EntryState::Merged => self
                             .outcome
                             .lock()
                             .unwrap()
                             .modified
                             .push(hg_path.detach_from_tree()),
                         EntryState::Normal => self
                             .handle_normal_file(&dirstate_node, fs_metadata)?,
                     }
                 } else {
                     // `node.entry.is_none()` indicates a "directory"
                     // node, but the filesystem has a file
                     self.mark_unknown_or_ignored(
                         has_ignored_ancestor,
                         hg_path,
                     );
                 }
             }
 
             for child_node in dirstate_node.children(self.dmap.on_disk)?.iter()
             {
                 self.traverse_dirstate_only(child_node)?
             }
         }
         Ok(())
     }
 
     fn maybe_save_directory_mtime(
         &self,
         children_all_have_dirstate_node_or_are_ignored: bool,
         directory_metadata: &std::fs::Metadata,
         dirstate_node: NodeRef<'tree, 'on_disk>,
     ) -> Result<(), DirstateV2ParseError> {
         if children_all_have_dirstate_node_or_are_ignored {
             // All filesystem directory entries from `read_dir` have a
             // corresponding node in the dirstate, so we can reconstitute the
             // names of those entries without calling `read_dir` again.
             if let (Some(status_start), Ok(directory_mtime)) = (
                 &self.filesystem_time_at_status_start,
                 directory_metadata.modified(),
             ) {
                 // Although the Rust standard library’s `SystemTime` type
                 // has nanosecond precision, the times reported for a
                 // directory’s (or file’s) modified time may have lower
                 // resolution based on the filesystem (for example ext3
                 // only stores integer seconds), kernel (see
                 // https://stackoverflow.com/a/14393315/1162888), etc.
                 if &directory_mtime >= status_start {
                     // The directory was modified too recently, don’t cache its
                     // `read_dir` results.
                     //
                     // A timeline like this is possible:
                     //
                     // 1. A change to this directory (direct child was
                     //    added or removed) cause its mtime to be set
                     //    (possibly truncated) to `directory_mtime`
                     // 2. This `status` algorithm calls `read_dir`
                     // 3. An other change is made to the same directory is
                     //    made so that calling `read_dir` agin would give
                     //    different results, but soon enough after 1. that
                     //    the mtime stays the same
                     //
                     // On a system where the time resolution poor, this
                     // scenario is not unlikely if all three steps are caused
                     // by the same script.
                 } else {
                     // We’ve observed (through `status_start`) that time has
                     // “progressed” since `directory_mtime`, so any further
                     // change to this directory is extremely likely to cause a
                     // different mtime.
                     //
                     // Having the same mtime again is not entirely impossible
                     // since the system clock is not monotonous. It could jump
                     // backward to some point before `directory_mtime`, then a
                     // directory change could potentially happen during exactly
                     // the wrong tick.
                     //
                     // We deem this scenario (unlike the previous one) to be
                     // unlikely enough in practice.
                     let timestamp = directory_mtime.into();
                     let cached = dirstate_node.cached_directory_mtime();
                     if cached != Some(&timestamp) {
                         let hg_path = dirstate_node
                             .full_path_borrowed(self.dmap.on_disk)?
                             .detach_from_tree();
                         self.new_cachable_directories
                             .lock()
                             .unwrap()
                             .push((hg_path, timestamp))
                     }
                 }
             }
         }
         Ok(())
     }
 
     /// A file with `EntryState::Normal` in the dirstate was found in the
     /// filesystem
     fn handle_normal_file(
         &self,
         dirstate_node: &NodeRef<'tree, 'on_disk>,
         fs_metadata: &std::fs::Metadata,
     ) -> Result<(), DirstateV2ParseError> {
         // Keep the low 31 bits
         fn truncate_u64(value: u64) -> i32 {
             (value & 0x7FFF_FFFF) as i32
         }
         fn truncate_i64(value: i64) -> i32 {
             (value & 0x7FFF_FFFF) as i32
         }
 
         let entry = dirstate_node
             .entry()?
             .expect("handle_normal_file called with entry-less node");
         let hg_path = &dirstate_node.full_path_borrowed(self.dmap.on_disk)?;
         let mode_changed =
             || self.options.check_exec && entry.mode_changed(fs_metadata);
         let size = entry.size();
         let size_changed = size != truncate_u64(fs_metadata.len());
         if size >= 0 && size_changed && fs_metadata.file_type().is_symlink() {
             // issue6456: Size returned may be longer due to encryption
             // on EXT-4 fscrypt. TODO maybe only do it on EXT4?
             self.outcome
                 .lock()
                 .unwrap()
                 .unsure
                 .push(hg_path.detach_from_tree())
         } else if dirstate_node.has_copy_source()
             || entry.is_from_other_parent()
             || (size >= 0 && (size_changed || mode_changed()))
         {
             self.outcome
                 .lock()
                 .unwrap()
                 .modified
                 .push(hg_path.detach_from_tree())
         } else {
             let mtime = mtime_seconds(fs_metadata);
             if truncate_i64(mtime) != entry.mtime()
                 || mtime == self.options.last_normal_time
             {
                 self.outcome
                     .lock()
                     .unwrap()
                     .unsure
                     .push(hg_path.detach_from_tree())
             } else if self.options.list_clean {
                 self.outcome
                     .lock()
                     .unwrap()
                     .clean
                     .push(hg_path.detach_from_tree())
             }
         }
         Ok(())
     }
 
     /// A node in the dirstate tree has no corresponding filesystem entry
     fn traverse_dirstate_only(
         &self,
         dirstate_node: NodeRef<'tree, 'on_disk>,
     ) -> Result<(), DirstateV2ParseError> {
         self.check_for_outdated_directory_cache(&dirstate_node)?;
         self.mark_removed_or_deleted_if_file(
             &dirstate_node.full_path_borrowed(self.dmap.on_disk)?,
             dirstate_node.state()?,
         );
         dirstate_node
             .children(self.dmap.on_disk)?
             .par_iter()
             .map(|child_node| self.traverse_dirstate_only(child_node))
             .collect()
     }
 
     /// A node in the dirstate tree has no corresponding *file* on the
     /// filesystem
     ///
     /// Does nothing on a "directory" node
     fn mark_removed_or_deleted_if_file(
         &self,
         hg_path: &BorrowedPath<'tree, 'on_disk>,
         dirstate_node_state: Option<EntryState>,
     ) {
         if let Some(state) = dirstate_node_state {
             if self.matcher.matches(hg_path) {
                 if let EntryState::Removed = state {
                     self.outcome
                         .lock()
                         .unwrap()
                         .removed
                         .push(hg_path.detach_from_tree())
                 } else {
                     self.outcome
                         .lock()
                         .unwrap()
                         .deleted
                         .push(hg_path.detach_from_tree())
                 }
             }
         }
     }
 
     /// Something in the filesystem has no corresponding dirstate node
     ///
     /// Returns whether that path is ignored
     fn traverse_fs_only(
         &self,
         has_ignored_ancestor: bool,
         directory_hg_path: &HgPath,
         fs_entry: &DirEntry,
     ) -> bool {
         let hg_path = directory_hg_path.join(&fs_entry.base_name);
         let file_type = fs_entry.metadata.file_type();
         let file_or_symlink = file_type.is_file() || file_type.is_symlink();
         if file_type.is_dir() {
             let is_ignored =
                 has_ignored_ancestor || (self.ignore_fn)(&hg_path);
             let traverse_children = if is_ignored {
                 // Descendants of an ignored directory are all ignored
                 self.options.list_ignored
             } else {
                 // Descendants of an unknown directory may be either unknown or
                 // ignored
                 self.options.list_unknown || self.options.list_ignored
             };
             if traverse_children {
                 let is_at_repo_root = false;
                 if let Ok(children_fs_entries) = self.read_dir(
                     &hg_path,
                     &fs_entry.full_path,
                     is_at_repo_root,
                 ) {
                     children_fs_entries.par_iter().for_each(|child_fs_entry| {
                         self.traverse_fs_only(
                             is_ignored,
                             &hg_path,
                             child_fs_entry,
                         );
                     })
                 }
             }
             if self.options.collect_traversed_dirs {
                 self.outcome.lock().unwrap().traversed.push(hg_path.into())
             }
             is_ignored
         } else {
             if file_or_symlink {
                 if self.matcher.matches(&hg_path) {
                     self.mark_unknown_or_ignored(
                         has_ignored_ancestor,
                         &BorrowedPath::InMemory(&hg_path),
                     )
                 } else {
                     // We haven’t computed whether this path is ignored. It
                     // might not be, and a future run of status might have a
                     // different matcher that matches it. So treat it as not
                     // ignored. That is, inhibit readdir caching of the parent
                     // directory.
                     false
                 }
             } else {
                 // This is neither a directory, a plain file, or a symlink.
                 // Treat it like an ignored file.
                 true
             }
         }
     }
 
     /// Returns whether that path is ignored
     fn mark_unknown_or_ignored(
         &self,
         has_ignored_ancestor: bool,
         hg_path: &BorrowedPath<'_, 'on_disk>,
     ) -> bool {
         let is_ignored = has_ignored_ancestor || (self.ignore_fn)(&hg_path);
         if is_ignored {
             if self.options.list_ignored {
                 self.outcome
                     .lock()
                     .unwrap()
                     .ignored
                     .push(hg_path.detach_from_tree())
             }
         } else {
             if self.options.list_unknown {
                 self.outcome
                     .lock()
                     .unwrap()
                     .unknown
                     .push(hg_path.detach_from_tree())
             }
         }
         is_ignored
     }
 }
 
 #[cfg(unix)] // TODO
 fn mtime_seconds(metadata: &std::fs::Metadata) -> i64 {
     // Going through `Metadata::modified()` would be portable, but would take
     // care to construct a `SystemTime` value with sub-second precision just
     // for us to throw that away here.
     use std::os::unix::fs::MetadataExt;
     metadata.mtime()
 }
 
 struct DirEntry {
     base_name: HgPathBuf,
     full_path: PathBuf,
     metadata: std::fs::Metadata,
 }
 
 impl DirEntry {
     /// Returns **unsorted** entries in the given directory, with name and
     /// metadata.
     ///
     /// If a `.hg` sub-directory is encountered:
     ///
     /// * At the repository root, ignore that sub-directory
     /// * Elsewhere, we’re listing the content of a sub-repo. Return an empty
     ///   list instead.
     fn read_dir(path: &Path, is_at_repo_root: bool) -> io::Result<Vec<Self>> {
         let mut results = Vec::new();
         for entry in path.read_dir()? {
             let entry = entry?;
             let metadata = entry.metadata()?;
             let name = get_bytes_from_os_string(entry.file_name());
             // FIXME don't do this when cached
             if name == b".hg" {
                 if is_at_repo_root {
                     // Skip the repo’s own .hg (might be a symlink)
                     continue;
                 } else if metadata.is_dir() {
                     // A .hg sub-directory at another location means a subrepo,
                     // skip it entirely.
                     return Ok(Vec::new());
                 }
             }
             results.push(DirEntry {
                 base_name: name.into(),
                 full_path: entry.path(),
                 metadata,
             })
         }
         Ok(results)
     }
 }
 
 /// Return the `mtime` of a temporary file newly-created in the `.hg` directory
 /// of the give repository.
 ///
 /// This is similar to `SystemTime::now()`, with the result truncated to the
 /// same time resolution as other files’ modification times. Using `.hg`
 /// instead of the system’s default temporary directory (such as `/tmp`) makes
 /// it more likely the temporary file is in the same disk partition as contents
 /// of the working directory, which can matter since different filesystems may
 /// store timestamps with different resolutions.
 ///
 /// This may fail, typically if we lack write permissions. In that case we
 /// should continue the `status()` algoritm anyway and consider the current
 /// date/time to be unknown.
 fn filesystem_now(repo_root: &Path) -> Result<SystemTime, io::Error> {
     tempfile::tempfile_in(repo_root.join(".hg"))?
         .metadata()?
         .modified()
 }