rhg: Fix status desambiguation of symlinks and executable files

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

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

@@ -1,643 +1,649 b''
 use crate::dirstate_tree::on_disk::DirstateV2ParseError;
 use crate::errors::HgError;
 use bitflags::bitflags;
 use std::convert::{TryFrom, TryInto};
 use std::fs;
 use std::io;
 use std::time::{SystemTime, UNIX_EPOCH};
 
 #[derive(Copy, Clone, Debug, Eq, PartialEq)]
 pub enum EntryState {
     Normal,
     Added,
     Removed,
     Merged,
 }
 
 /// `size` and `mtime.seconds` are truncated to 31 bits.
 ///
 /// TODO: double-check status algorithm correctness for files
 /// larger than 2 GiB or modified after 2038.
 #[derive(Debug, Copy, Clone)]
 pub struct DirstateEntry {
     pub(crate) flags: Flags,
     mode_size: Option<(u32, u32)>,
     mtime: Option<TruncatedTimestamp>,
 }
 
 bitflags! {
     pub(crate) struct Flags: u8 {
         const WDIR_TRACKED = 1 << 0;
         const P1_TRACKED = 1 << 1;
         const P2_INFO = 1 << 2;
         const HAS_FALLBACK_EXEC = 1 << 3;
         const FALLBACK_EXEC = 1 << 4;
         const HAS_FALLBACK_SYMLINK = 1 << 5;
         const FALLBACK_SYMLINK = 1 << 6;
     }
 }
 
 /// A Unix timestamp with nanoseconds precision
 #[derive(Debug, Copy, Clone)]
 pub struct TruncatedTimestamp {
     truncated_seconds: u32,
     /// Always in the `0 .. 1_000_000_000` range.
     nanoseconds: u32,
 }
 
 impl TruncatedTimestamp {
     /// Constructs from a timestamp potentially outside of the supported range,
     /// and truncate the seconds components to its lower 31 bits.
     ///
     /// Panics if the nanoseconds components is not in the expected range.
     pub fn new_truncate(seconds: i64, nanoseconds: u32) -> Self {
         assert!(nanoseconds < NSEC_PER_SEC);
         Self {
             truncated_seconds: seconds as u32 & RANGE_MASK_31BIT,
             nanoseconds,
         }
     }
 
     /// Construct from components. Returns an error if they are not in the
     /// expcted range.
     pub fn from_already_truncated(
         truncated_seconds: u32,
         nanoseconds: u32,
     ) -> Result<Self, DirstateV2ParseError> {
         if truncated_seconds & !RANGE_MASK_31BIT == 0
             && nanoseconds < NSEC_PER_SEC
         {
             Ok(Self {
                 truncated_seconds,
                 nanoseconds,
             })
         } else {
             Err(DirstateV2ParseError)
         }
     }
 
     pub fn for_mtime_of(metadata: &fs::Metadata) -> io::Result<Self> {
         #[cfg(unix)]
         {
             use std::os::unix::fs::MetadataExt;
             let seconds = metadata.mtime();
             // i64 -> u32 with value always in the `0 .. NSEC_PER_SEC` range
             let nanoseconds = metadata.mtime_nsec().try_into().unwrap();
             Ok(Self::new_truncate(seconds, nanoseconds))
         }
         #[cfg(not(unix))]
         {
             metadata.modified().map(Self::from)
         }
     }
 
     /// The lower 31 bits of the number of seconds since the epoch.
     pub fn truncated_seconds(&self) -> u32 {
         self.truncated_seconds
     }
 
     /// The sub-second component of this timestamp, in nanoseconds.
     /// Always in the `0 .. 1_000_000_000` range.
     ///
     /// This timestamp is after `(seconds, 0)` by this many nanoseconds.
     pub fn nanoseconds(&self) -> u32 {
         self.nanoseconds
     }
 
     /// Returns whether two timestamps are equal modulo 2**31 seconds.
     ///
     /// If this returns `true`, the original values converted from `SystemTime`
     /// or given to `new_truncate` were very likely equal. A false positive is
     /// possible if they were exactly a multiple of 2**31 seconds apart (around
     /// 68 years). This is deemed very unlikely to happen by chance, especially
     /// on filesystems that support sub-second precision.
     ///
     /// If someone is manipulating the modification times of some files to
     /// intentionally make `hg status` return incorrect results, not truncating
     /// wouldn’t help much since they can set exactly the expected timestamp.
     ///
     /// Sub-second precision is ignored if it is zero in either value.
     /// Some APIs simply return zero when more precision is not available.
     /// When comparing values from different sources, if only one is truncated
     /// in that way, doing a simple comparison would cause many false
     /// negatives.
     pub fn likely_equal(self, other: Self) -> bool {
         self.truncated_seconds == other.truncated_seconds
             && (self.nanoseconds == other.nanoseconds
                 || self.nanoseconds == 0
                 || other.nanoseconds == 0)
     }
 
     pub fn likely_equal_to_mtime_of(
         self,
         metadata: &fs::Metadata,
     ) -> io::Result<bool> {
         Ok(self.likely_equal(Self::for_mtime_of(metadata)?))
     }
 }
 
 impl From<SystemTime> for TruncatedTimestamp {
     fn from(system_time: SystemTime) -> Self {
         // On Unix, `SystemTime` is a wrapper for the `timespec` C struct:
         // https://www.gnu.org/software/libc/manual/html_node/Time-Types.html#index-struct-timespec
         // We want to effectively access its fields, but the Rust standard
         // library does not expose them. The best we can do is:
         let seconds;
         let nanoseconds;
         match system_time.duration_since(UNIX_EPOCH) {
             Ok(duration) => {
                 seconds = duration.as_secs() as i64;
                 nanoseconds = duration.subsec_nanos();
             }
             Err(error) => {
                 // `system_time` is before `UNIX_EPOCH`.
                 // We need to undo this algorithm:
                 // https://github.com/rust-lang/rust/blob/6bed1f0bc3cc50c10aab26d5f94b16a00776b8a5/library/std/src/sys/unix/time.rs#L40-L41
                 let negative = error.duration();
                 let negative_secs = negative.as_secs() as i64;
                 let negative_nanos = negative.subsec_nanos();
                 if negative_nanos == 0 {
                     seconds = -negative_secs;
                     nanoseconds = 0;
                 } else {
                     // For example if `system_time` was 4.3 seconds before
                     // the Unix epoch we get a Duration that represents
                     // `(-4, -0.3)` but we want `(-5, +0.7)`:
                     seconds = -1 - negative_secs;
                     nanoseconds = NSEC_PER_SEC - negative_nanos;
                 }
             }
         };
         Self::new_truncate(seconds, nanoseconds)
     }
 }
 
 const NSEC_PER_SEC: u32 = 1_000_000_000;
 const RANGE_MASK_31BIT: u32 = 0x7FFF_FFFF;
 
 pub const MTIME_UNSET: i32 = -1;
 
 /// A `DirstateEntry` with a size of `-2` means that it was merged from the
 /// other parent. This allows revert to pick the right status back during a
 /// merge.
 pub const SIZE_FROM_OTHER_PARENT: i32 = -2;
 /// A special value used for internal representation of special case in
 /// dirstate v1 format.
 pub const SIZE_NON_NORMAL: i32 = -1;
 
 impl DirstateEntry {
     pub fn from_v2_data(
         wdir_tracked: bool,
         p1_tracked: bool,
         p2_info: bool,
         mode_size: Option<(u32, u32)>,
         mtime: Option<TruncatedTimestamp>,
         fallback_exec: Option<bool>,
         fallback_symlink: Option<bool>,
     ) -> Self {
         if let Some((mode, size)) = mode_size {
             // TODO: return an error for out of range values?
             assert!(mode & !RANGE_MASK_31BIT == 0);
             assert!(size & !RANGE_MASK_31BIT == 0);
         }
         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);
         if let Some(exec) = fallback_exec {
             flags.insert(Flags::HAS_FALLBACK_EXEC);
             if exec {
                 flags.insert(Flags::FALLBACK_EXEC);
             }
         }
         if let Some(exec) = fallback_symlink {
             flags.insert(Flags::HAS_FALLBACK_SYMLINK);
             if exec {
                 flags.insert(Flags::FALLBACK_SYMLINK);
             }
         }
         Self {
             flags,
             mode_size,
             mtime,
         }
     }
 
     pub fn from_v1_data(
         state: EntryState,
         mode: i32,
         size: i32,
         mtime: i32,
     ) -> Self {
         match state {
             EntryState::Normal => {
                 if size == SIZE_FROM_OTHER_PARENT {
                     Self {
                         // might be missing P1_TRACKED
                         flags: Flags::WDIR_TRACKED | Flags::P2_INFO,
                         mode_size: None,
                         mtime: None,
                     }
                 } else if size == SIZE_NON_NORMAL {
                     Self {
                         flags: Flags::WDIR_TRACKED | Flags::P1_TRACKED,
                         mode_size: None,
                         mtime: None,
                     }
                 } else if mtime == MTIME_UNSET {
                     // TODO: return an error for negative values?
                     let mode = u32::try_from(mode).unwrap();
                     let size = u32::try_from(size).unwrap();
                     Self {
                         flags: Flags::WDIR_TRACKED | Flags::P1_TRACKED,
                         mode_size: Some((mode, size)),
                         mtime: None,
                     }
                 } else {
                     // TODO: return an error for negative values?
                     let mode = u32::try_from(mode).unwrap();
                     let size = u32::try_from(size).unwrap();
                     let mtime = u32::try_from(mtime).unwrap();
                     let mtime =
                         TruncatedTimestamp::from_already_truncated(mtime, 0)
                             .unwrap();
                     Self {
                         flags: Flags::WDIR_TRACKED | Flags::P1_TRACKED,
                         mode_size: Some((mode, size)),
                         mtime: Some(mtime),
                     }
                 }
             }
             EntryState::Added => Self {
                 flags: Flags::WDIR_TRACKED,
                 mode_size: None,
                 mtime: None,
             },
             EntryState::Removed => Self {
                 flags: if size == SIZE_NON_NORMAL {
                     Flags::P1_TRACKED | Flags::P2_INFO
                 } else if size == SIZE_FROM_OTHER_PARENT {
                     // We don’t know if P1_TRACKED should be set (file history)
                     Flags::P2_INFO
                 } else {
                     Flags::P1_TRACKED
                 },
                 mode_size: None,
                 mtime: None,
             },
             EntryState::Merged => Self {
                 flags: Flags::WDIR_TRACKED
                     | Flags::P1_TRACKED // might not be true because of rename ?
                     | Flags::P2_INFO, // might not be true because of rename ?
                 mode_size: None,
                 mtime: None,
             },
         }
     }
 
     /// Creates a new entry in "removed" state.
     ///
     /// `size` is expected to be zero, `SIZE_NON_NORMAL`, or
     /// `SIZE_FROM_OTHER_PARENT`
     pub fn new_removed(size: i32) -> Self {
         Self::from_v1_data(EntryState::Removed, 0, size, 0)
     }
 
     pub fn tracked(&self) -> bool {
         self.flags.contains(Flags::WDIR_TRACKED)
     }
 
     pub fn p1_tracked(&self) -> bool {
         self.flags.contains(Flags::P1_TRACKED)
     }
 
     fn in_either_parent(&self) -> bool {
         self.flags.intersects(Flags::P1_TRACKED | Flags::P2_INFO)
     }
 
     pub fn removed(&self) -> bool {
         self.in_either_parent() && !self.flags.contains(Flags::WDIR_TRACKED)
     }
 
     pub fn p2_info(&self) -> bool {
         self.flags.contains(Flags::WDIR_TRACKED | Flags::P2_INFO)
     }
 
     pub fn added(&self) -> bool {
         self.flags.contains(Flags::WDIR_TRACKED) && !self.in_either_parent()
     }
 
     pub fn maybe_clean(&self) -> bool {
         if !self.flags.contains(Flags::WDIR_TRACKED) {
             false
         } else if !self.flags.contains(Flags::P1_TRACKED) {
             false
         } else if self.flags.contains(Flags::P2_INFO) {
             false
         } else {
             true
         }
     }
 
     pub fn any_tracked(&self) -> bool {
         self.flags.intersects(
             Flags::WDIR_TRACKED | Flags::P1_TRACKED | Flags::P2_INFO,
         )
     }
 
     /// Returns `(wdir_tracked, p1_tracked, p2_info, mode_size, mtime)`
     pub(crate) fn v2_data(
         &self,
     ) -> (
         bool,
         bool,
         bool,
         Option<(u32, u32)>,
         Option<TruncatedTimestamp>,
         Option<bool>,
         Option<bool>,
     ) {
         if !self.any_tracked() {
             // TODO: return an Option instead?
             panic!("Accessing v1_state of an untracked DirstateEntry")
         }
         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 = self.mode_size;
         let mtime = self.mtime;
         (
             wdir_tracked,
             p1_tracked,
             p2_info,
             mode_size,
             mtime,
             self.get_fallback_exec(),
             self.get_fallback_symlink(),
         )
     }
 
     fn v1_state(&self) -> EntryState {
         if !self.any_tracked() {
             // TODO: return an Option instead?
             panic!("Accessing v1_state of an untracked DirstateEntry")
         }
         if self.removed() {
             EntryState::Removed
         } else if self
             .flags
             .contains(Flags::WDIR_TRACKED | Flags::P1_TRACKED | Flags::P2_INFO)
         {
             EntryState::Merged
         } else if self.added() {
             EntryState::Added
         } else {
             EntryState::Normal
         }
     }
 
     fn v1_mode(&self) -> i32 {
         if let Some((mode, _size)) = self.mode_size {
             i32::try_from(mode).unwrap()
         } else {
             0
         }
     }
 
     fn v1_size(&self) -> i32 {
         if !self.any_tracked() {
             // TODO: return an Option instead?
             panic!("Accessing v1_size of an untracked DirstateEntry")
         }
         if self.removed()
             && self.flags.contains(Flags::P1_TRACKED | Flags::P2_INFO)
         {
             SIZE_NON_NORMAL
         } else if self.flags.contains(Flags::P2_INFO) {
             SIZE_FROM_OTHER_PARENT
         } else if self.removed() {
             0
         } else if self.added() {
             SIZE_NON_NORMAL
         } else if let Some((_mode, size)) = self.mode_size {
             i32::try_from(size).unwrap()
         } else {
             SIZE_NON_NORMAL
         }
     }
 
     fn v1_mtime(&self) -> i32 {
         if !self.any_tracked() {
             // TODO: return an Option instead?
             panic!("Accessing v1_mtime of an untracked DirstateEntry")
         }
         if self.removed() {
             0
         } else if self.flags.contains(Flags::P2_INFO) {
             MTIME_UNSET
         } else if !self.flags.contains(Flags::P1_TRACKED) {
             MTIME_UNSET
         } else if let Some(mtime) = self.mtime {
             i32::try_from(mtime.truncated_seconds()).unwrap()
         } else {
             MTIME_UNSET
         }
     }
 
     // TODO: return `Option<EntryState>`? None when `!self.any_tracked`
     pub fn state(&self) -> EntryState {
         self.v1_state()
     }
 
     // TODO: return Option?
     pub fn mode(&self) -> i32 {
         self.v1_mode()
     }
 
     // TODO: return Option?
     pub fn size(&self) -> i32 {
         self.v1_size()
     }
 
     // TODO: return Option?
     pub fn mtime(&self) -> i32 {
         self.v1_mtime()
     }
 
     pub fn get_fallback_exec(&self) -> Option<bool> {
         if self.flags.contains(Flags::HAS_FALLBACK_EXEC) {
             Some(self.flags.contains(Flags::FALLBACK_EXEC))
         } else {
             None
         }
     }
 
     pub fn set_fallback_exec(&mut self, value: Option<bool>) {
         match value {
             None => {
                 self.flags.remove(Flags::HAS_FALLBACK_EXEC);
                 self.flags.remove(Flags::FALLBACK_EXEC);
             }
             Some(exec) => {
                 self.flags.insert(Flags::HAS_FALLBACK_EXEC);
                 if exec {
                     self.flags.insert(Flags::FALLBACK_EXEC);
                 }
             }
         }
     }
 
     pub fn get_fallback_symlink(&self) -> Option<bool> {
         if self.flags.contains(Flags::HAS_FALLBACK_SYMLINK) {
             Some(self.flags.contains(Flags::FALLBACK_SYMLINK))
         } else {
             None
         }
     }
 
     pub fn set_fallback_symlink(&mut self, value: Option<bool>) {
         match value {
             None => {
                 self.flags.remove(Flags::HAS_FALLBACK_SYMLINK);
                 self.flags.remove(Flags::FALLBACK_SYMLINK);
             }
             Some(symlink) => {
                 self.flags.insert(Flags::HAS_FALLBACK_SYMLINK);
                 if symlink {
                     self.flags.insert(Flags::FALLBACK_SYMLINK);
                 }
             }
         }
     }
 
     pub fn truncated_mtime(&self) -> Option<TruncatedTimestamp> {
         self.mtime
     }
 
     pub fn drop_merge_data(&mut self) {
         if self.flags.contains(Flags::P2_INFO) {
             self.flags.remove(Flags::P2_INFO);
             self.mode_size = None;
             self.mtime = None;
         }
     }
 
     pub fn set_possibly_dirty(&mut self) {
         self.mtime = None
     }
 
     pub fn set_clean(
         &mut self,
         mode: u32,
         size: u32,
         mtime: TruncatedTimestamp,
     ) {
         let size = size & RANGE_MASK_31BIT;
         self.flags.insert(Flags::WDIR_TRACKED | Flags::P1_TRACKED);
         self.mode_size = Some((mode, size));
         self.mtime = Some(mtime);
     }
 
     pub fn set_tracked(&mut self) {
         self.flags.insert(Flags::WDIR_TRACKED);
         // `set_tracked` is replacing various `normallookup` call. So we mark
         // the files as needing lookup
         //
         // Consider dropping this in the future in favor of something less
         // broad.
         self.mtime = None;
     }
 
     pub fn set_untracked(&mut self) {
         self.flags.remove(Flags::WDIR_TRACKED);
         self.mode_size = None;
         self.mtime = None;
     }
 
     /// Returns `(state, mode, size, mtime)` for the puprose of serialization
     /// in the dirstate-v1 format.
     ///
     /// This includes marker values such as `mtime == -1`. In the future we may
     /// want to not represent these cases that way in memory, but serialization
     /// will need to keep the same format.
     pub fn v1_data(&self) -> (u8, i32, i32, i32) {
         (
             self.v1_state().into(),
             self.v1_mode(),
             self.v1_size(),
             self.v1_mtime(),
         )
     }
 
     pub(crate) fn is_from_other_parent(&self) -> bool {
         self.state() == EntryState::Normal
             && self.size() == SIZE_FROM_OTHER_PARENT
     }
 
     // TODO: other platforms
     #[cfg(unix)]
     pub fn mode_changed(
         &self,
         filesystem_metadata: &std::fs::Metadata,
     ) -> bool {
-        use std::os::unix::fs::MetadataExt;
-        const EXEC_BIT_MASK: u32 = 0o100;
-        let dirstate_exec_bit = (self.mode() as u32) & EXEC_BIT_MASK;
-        let fs_exec_bit = filesystem_metadata.mode() & EXEC_BIT_MASK;
+        let dirstate_exec_bit = (self.mode() as u32 & EXEC_BIT_MASK) != 0;
+        let fs_exec_bit = has_exec_bit(filesystem_metadata);
         dirstate_exec_bit != fs_exec_bit
     }
 
     /// Returns a `(state, mode, size, mtime)` tuple as for
     /// `DirstateMapMethods::debug_iter`.
     pub fn debug_tuple(&self) -> (u8, i32, i32, i32) {
         (self.state().into(), self.mode(), self.size(), self.mtime())
     }
 
     /// True if the stored mtime would be ambiguous with the current time
     pub fn need_delay(&self, now: TruncatedTimestamp) -> bool {
         if let Some(mtime) = self.mtime {
             self.state() == EntryState::Normal
                 && mtime.truncated_seconds() == now.truncated_seconds()
         } else {
             false
         }
     }
 }
 
 impl EntryState {
     pub fn is_tracked(self) -> bool {
         use EntryState::*;
         match self {
             Normal | Added | Merged => true,
             Removed => false,
         }
     }
 }
 
 impl TryFrom<u8> for EntryState {
     type Error = HgError;
 
     fn try_from(value: u8) -> Result<Self, Self::Error> {
         match value {
             b'n' => Ok(EntryState::Normal),
             b'a' => Ok(EntryState::Added),
             b'r' => Ok(EntryState::Removed),
             b'm' => Ok(EntryState::Merged),
             _ => Err(HgError::CorruptedRepository(format!(
                 "Incorrect dirstate entry state {}",
                 value
             ))),
         }
     }
 }
 
 impl Into<u8> for EntryState {
     fn into(self) -> u8 {
         match self {
             EntryState::Normal => b'n',
             EntryState::Added => b'a',
             EntryState::Removed => b'r',
             EntryState::Merged => b'm',
         }
     }
 }
+
+const EXEC_BIT_MASK: u32 = 0o100;
+
+pub fn has_exec_bit(metadata: &std::fs::Metadata) -> bool {
+    // TODO: How to handle executable permissions on Windows?
+    use std::os::unix::fs::MetadataExt;
+    (metadata.mode() & EXEC_BIT_MASK) != 0
+}

rust/hg-core/src/vfs.rs

@@ -1,100 +1,116 b''
 use crate::errors::{HgError, IoErrorContext, IoResultExt};
 use memmap2::{Mmap, MmapOptions};
 use std::io::ErrorKind;
 use std::path::{Path, PathBuf};
 
 /// Filesystem access abstraction for the contents of a given "base" diretory
 #[derive(Clone, Copy)]
 pub struct Vfs<'a> {
     pub(crate) base: &'a Path,
 }
 
 struct FileNotFound(std::io::Error, PathBuf);
 
 impl Vfs<'_> {
     pub fn join(&self, relative_path: impl AsRef<Path>) -> PathBuf {
         self.base.join(relative_path)
     }
 
+    pub fn symlink_metadata(
+        &self,
+        relative_path: impl AsRef<Path>,
+    ) -> Result<std::fs::Metadata, HgError> {
+        let path = self.join(relative_path);
+        std::fs::symlink_metadata(&path).when_reading_file(&path)
+    }
+
+    pub fn read_link(
+        &self,
+        relative_path: impl AsRef<Path>,
+    ) -> Result<PathBuf, HgError> {
+        let path = self.join(relative_path);
+        std::fs::read_link(&path).when_reading_file(&path)
+    }
+
     pub fn read(
         &self,
         relative_path: impl AsRef<Path>,
     ) -> Result<Vec<u8>, HgError> {
         let path = self.join(relative_path);
         std::fs::read(&path).when_reading_file(&path)
     }
 
     fn mmap_open_gen(
         &self,
         relative_path: impl AsRef<Path>,
     ) -> Result<Result<Mmap, FileNotFound>, HgError> {
         let path = self.join(relative_path);
         let file = match std::fs::File::open(&path) {
             Err(err) => {
                 if let ErrorKind::NotFound = err.kind() {
                     return Ok(Err(FileNotFound(err, path)));
                 };
                 return (Err(err)).when_reading_file(&path);
             }
             Ok(file) => file,
         };
         // TODO: what are the safety requirements here?
         let mmap = unsafe { MmapOptions::new().map(&file) }
             .when_reading_file(&path)?;
         Ok(Ok(mmap))
     }
 
     pub fn mmap_open_opt(
         &self,
         relative_path: impl AsRef<Path>,
     ) -> Result<Option<Mmap>, HgError> {
         self.mmap_open_gen(relative_path).map(|res| res.ok())
     }
 
     pub fn mmap_open(
         &self,
         relative_path: impl AsRef<Path>,
     ) -> Result<Mmap, HgError> {
         match self.mmap_open_gen(relative_path)? {
             Err(FileNotFound(err, path)) => Err(err).when_reading_file(&path),
             Ok(res) => Ok(res),
         }
     }
 
     pub fn rename(
         &self,
         relative_from: impl AsRef<Path>,
         relative_to: impl AsRef<Path>,
     ) -> Result<(), HgError> {
         let from = self.join(relative_from);
         let to = self.join(relative_to);
         std::fs::rename(&from, &to)
             .with_context(|| IoErrorContext::RenamingFile { from, to })
     }
 }
 
 fn fs_metadata(
     path: impl AsRef<Path>,
 ) -> Result<Option<std::fs::Metadata>, HgError> {
     let path = path.as_ref();
     match std::fs::metadata(path) {
         Ok(meta) => Ok(Some(meta)),
         Err(error) => match error.kind() {
             // TODO: when we require a Rust version where `NotADirectory` is
             // stable, invert this logic and return None for it and `NotFound`
             // and propagate any other error.
             ErrorKind::PermissionDenied => Err(error).with_context(|| {
                 IoErrorContext::ReadingMetadata(path.to_owned())
             }),
             _ => Ok(None),
         },
     }
 }
 
 pub(crate) fn is_dir(path: impl AsRef<Path>) -> Result<bool, HgError> {
     Ok(fs_metadata(path)?.map_or(false, |meta| meta.is_dir()))
 }
 
 pub(crate) fn is_file(path: impl AsRef<Path>) -> Result<bool, HgError> {
     Ok(fs_metadata(path)?.map_or(false, |meta| meta.is_file()))
 }

rust/rhg/src/commands/status.rs

@@ -1,325 +1,343 b''
 // status.rs
 //
 // Copyright 2020, Georges Racinet <[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::error::CommandError;
 use crate::ui::{Ui, UiError};
 use crate::utils::path_utils::relativize_paths;
 use clap::{Arg, SubCommand};
 use hg;
 use hg::config::Config;
-use hg::dirstate::TruncatedTimestamp;
+use hg::dirstate::{has_exec_bit, TruncatedTimestamp};
 use hg::errors::HgError;
 use hg::manifest::Manifest;
 use hg::matchers::AlwaysMatcher;
 use hg::repo::Repo;
+use hg::utils::files::get_bytes_from_os_string;
 use hg::utils::hg_path::{hg_path_to_os_string, HgPath};
 use hg::{HgPathCow, StatusOptions};
 use log::{info, warn};
 use std::borrow::Cow;
 
 pub const HELP_TEXT: &str = "
 Show changed files in the working directory
 
 This is a pure Rust version of `hg status`.
 
 Some options might be missing, check the list below.
 ";
 
 pub fn args() -> clap::App<'static, 'static> {
     SubCommand::with_name("status")
         .alias("st")
         .about(HELP_TEXT)
         .arg(
             Arg::with_name("all")
                 .help("show status of all files")
                 .short("-A")
                 .long("--all"),
         )
         .arg(
             Arg::with_name("modified")
                 .help("show only modified files")
                 .short("-m")
                 .long("--modified"),
         )
         .arg(
             Arg::with_name("added")
                 .help("show only added files")
                 .short("-a")
                 .long("--added"),
         )
         .arg(
             Arg::with_name("removed")
                 .help("show only removed files")
                 .short("-r")
                 .long("--removed"),
         )
         .arg(
             Arg::with_name("clean")
                 .help("show only clean files")
                 .short("-c")
                 .long("--clean"),
         )
         .arg(
             Arg::with_name("deleted")
                 .help("show only deleted files")
                 .short("-d")
                 .long("--deleted"),
         )
         .arg(
             Arg::with_name("unknown")
                 .help("show only unknown (not tracked) files")
                 .short("-u")
                 .long("--unknown"),
         )
         .arg(
             Arg::with_name("ignored")
                 .help("show only ignored files")
                 .short("-i")
                 .long("--ignored"),
         )
 }
 
 /// Pure data type allowing the caller to specify file states to display
 #[derive(Copy, Clone, Debug)]
 pub struct DisplayStates {
     pub modified: bool,
     pub added: bool,
     pub removed: bool,
     pub clean: bool,
     pub deleted: bool,
     pub unknown: bool,
     pub ignored: bool,
 }
 
 pub const DEFAULT_DISPLAY_STATES: DisplayStates = DisplayStates {
     modified: true,
     added: true,
     removed: true,
     clean: false,
     deleted: true,
     unknown: true,
     ignored: false,
 };
 
 pub const ALL_DISPLAY_STATES: DisplayStates = DisplayStates {
     modified: true,
     added: true,
     removed: true,
     clean: true,
     deleted: true,
     unknown: true,
     ignored: true,
 };
 
 impl DisplayStates {
     pub fn is_empty(&self) -> bool {
         !(self.modified
             || self.added
             || self.removed
             || self.clean
             || self.deleted
             || self.unknown
             || self.ignored)
     }
 }
 
 pub fn run(invocation: &crate::CliInvocation) -> Result<(), CommandError> {
     let status_enabled_default = false;
     let status_enabled = invocation.config.get_option(b"rhg", b"status")?;
     if !status_enabled.unwrap_or(status_enabled_default) {
         return Err(CommandError::unsupported(
             "status is experimental in rhg (enable it with 'rhg.status = true' \
             or enable fallback with 'rhg.on-unsupported = fallback')"
         ));
     }
 
     // TODO: lift these limitations
     if invocation.config.get_bool(b"ui", b"tweakdefaults")? {
         return Err(CommandError::unsupported(
             "ui.tweakdefaults is not yet supported with rhg status",
         ));
     }
     if invocation.config.get_bool(b"ui", b"statuscopies")? {
         return Err(CommandError::unsupported(
             "ui.statuscopies is not yet supported with rhg status",
         ));
     }
     if invocation
         .config
         .get(b"commands", b"status.terse")
         .is_some()
     {
         return Err(CommandError::unsupported(
             "status.terse is not yet supported with rhg status",
         ));
     }
 
     let ui = invocation.ui;
     let config = invocation.config;
     let args = invocation.subcommand_args;
     let display_states = if args.is_present("all") {
         // TODO when implementing `--quiet`: it excludes clean files
         // from `--all`
         ALL_DISPLAY_STATES
     } else {
         let requested = DisplayStates {
             modified: args.is_present("modified"),
             added: args.is_present("added"),
             removed: args.is_present("removed"),
             clean: args.is_present("clean"),
             deleted: args.is_present("deleted"),
             unknown: args.is_present("unknown"),
             ignored: args.is_present("ignored"),
         };
         if requested.is_empty() {
             DEFAULT_DISPLAY_STATES
         } else {
             requested
         }
     };
 
     let repo = invocation.repo?;
     let mut dmap = repo.dirstate_map_mut()?;
 
     let options = StatusOptions {
         // TODO should be provided by the dirstate parsing and
         // hence be stored on dmap. Using a value that assumes we aren't
         // below the time resolution granularity of the FS and the
         // dirstate.
         last_normal_time: TruncatedTimestamp::new_truncate(0, 0),
         // we're currently supporting file systems with exec flags only
         // anyway
         check_exec: true,
         list_clean: display_states.clean,
         list_unknown: display_states.unknown,
         list_ignored: display_states.ignored,
         collect_traversed_dirs: false,
     };
     let ignore_file = repo.working_directory_vfs().join(".hgignore"); // TODO hardcoded
     let (mut ds_status, pattern_warnings) = dmap.status(
         &AlwaysMatcher,
         repo.working_directory_path().to_owned(),
         vec![ignore_file],
         options,
     )?;
     if !pattern_warnings.is_empty() {
         warn!("Pattern warnings: {:?}", &pattern_warnings);
     }
 
     if !ds_status.bad.is_empty() {
         warn!("Bad matches {:?}", &(ds_status.bad))
     }
     if !ds_status.unsure.is_empty() {
         info!(
             "Files to be rechecked by retrieval from filelog: {:?}",
             &ds_status.unsure
         );
     }
     if !ds_status.unsure.is_empty()
         && (display_states.modified || display_states.clean)
     {
         let p1 = repo.dirstate_parents()?.p1;
         let manifest = repo.manifest_for_node(p1).map_err(|e| {
             CommandError::from((e, &*format!("{:x}", p1.short())))
         })?;
         for to_check in ds_status.unsure {
             if unsure_is_modified(repo, &manifest, &to_check)? {
                 if display_states.modified {
                     ds_status.modified.push(to_check);
                 }
             } else {
                 if display_states.clean {
                     ds_status.clean.push(to_check);
                 }
             }
         }
     }
     if display_states.modified {
         display_status_paths(ui, repo, config, &mut ds_status.modified, b"M")?;
     }
     if display_states.added {
         display_status_paths(ui, repo, config, &mut ds_status.added, b"A")?;
     }
     if display_states.removed {
         display_status_paths(ui, repo, config, &mut ds_status.removed, b"R")?;
     }
     if display_states.deleted {
         display_status_paths(ui, repo, config, &mut ds_status.deleted, b"!")?;
     }
     if display_states.unknown {
         display_status_paths(ui, repo, config, &mut ds_status.unknown, b"?")?;
     }
     if display_states.ignored {
         display_status_paths(ui, repo, config, &mut ds_status.ignored, b"I")?;
     }
     if display_states.clean {
         display_status_paths(ui, repo, config, &mut ds_status.clean, b"C")?;
     }
     Ok(())
 }
 
 // Probably more elegant to use a Deref or Borrow trait rather than
 // harcode HgPathBuf, but probably not really useful at this point
 fn display_status_paths(
     ui: &Ui,
     repo: &Repo,
     config: &Config,
     paths: &mut [HgPathCow],
     status_prefix: &[u8],
 ) -> Result<(), CommandError> {
     paths.sort_unstable();
     let mut relative: bool = config.get_bool(b"ui", b"relative-paths")?;
     relative = config
         .get_option(b"commands", b"status.relative")?
         .unwrap_or(relative);
     if relative && !ui.plain() {
         relativize_paths(
             repo,
             paths.iter().map(Ok),
             |path: Cow<[u8]>| -> Result<(), UiError> {
                 ui.write_stdout(
                     &[status_prefix, b" ", path.as_ref(), b"\n"].concat(),
                 )
             },
         )?;
     } else {
         for path in paths {
             // Same TODO as in commands::root
             let bytes: &[u8] = path.as_bytes();
             // TODO optim, probably lots of unneeded copies here, especially
             // if out stream is buffered
             ui.write_stdout(&[status_prefix, b" ", bytes, b"\n"].concat())?;
         }
     }
     Ok(())
 }
 
 /// Check if a file is modified by comparing actual repo store and file system.
 ///
 /// This meant to be used for those that the dirstate cannot resolve, due
 /// to time resolution limits.
-///
-/// TODO: detect permission bits and similar metadata modifications
 fn unsure_is_modified(
     repo: &Repo,
     manifest: &Manifest,
     hg_path: &HgPath,
 ) -> Result<bool, HgError> {
+    let vfs = repo.working_directory_vfs();
+    let fs_path = hg_path_to_os_string(hg_path).expect("HgPath conversion");
+    let fs_metadata = vfs.symlink_metadata(&fs_path)?;
+    let is_symlink = fs_metadata.file_type().is_symlink();
+    // TODO: Also account for `FALLBACK_SYMLINK` and `FALLBACK_EXEC` from the dirstate
+    let fs_flags = if is_symlink {
+        Some(b'l')
+    } else if has_exec_bit(&fs_metadata) {
+        Some(b'x')
+    } else {
+        None
+    };
+
     let entry = manifest
         .find_file(hg_path)?
         .expect("ambgious file not in p1");
+    if entry.flags != fs_flags {
+        return Ok(true);
+    }
     let filelog = repo.filelog(hg_path)?;
     let filelog_entry =
         filelog.data_for_node(entry.node_id()?).map_err(|_| {
             HgError::corrupted("filelog missing node from manifest")
         })?;
     let contents_in_p1 = filelog_entry.data()?;
 
-    let fs_path = hg_path_to_os_string(hg_path).expect("HgPath conversion");
-    let fs_contents = repo.working_directory_vfs().read(fs_path)?;
+    let fs_contents = if is_symlink {
+        get_bytes_from_os_string(vfs.read_link(fs_path)?.into_os_string())
+    } else {
+        vfs.read(fs_path)?
+    };
     return Ok(contents_in_p1 != &*fs_contents);
 }

tests/test-execute-bit.t

@@ -1,32 +1,28 b''
 #require execbit
 
-TODO: fix rhg bugs that make this test fail when status is enabled
-  $ unset RHG_STATUS
-
-
   $ hg init
   $ echo a > a
   $ hg ci -Am'not executable'
   adding a
 
   $ chmod +x a
   $ hg ci -m'executable'
   $ hg id
   79abf14474dc tip
 
 Make sure we notice the change of mode if the cached size == -1:
 
   $ hg rm a
   $ hg revert -r 0 a
   $ hg debugstate
   n   0         -1 unset               a
   $ hg status
   M a
 
   $ hg up 0
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg id
   d69afc33ff8a
   $ test -x a && echo executable -- bad || echo not executable -- good
   not executable -- good
 

tests/test-merge-exec.t

@@ -1,437 +1,433 b''
 ===============================================
 Testing merge involving change to the exec flag
 ===============================================
 
 #require execbit
 
-TODO: fix rhg bugs that make this test fail when status is enabled
-  $ unset RHG_STATUS
-
-
 Initial setup
 ==============
 
 
   $ hg init base-repo
   $ cd base-repo
   $ cat << EOF > a
   > 1
   > 2
   > 3
   > 4
   > 5
   > 6
   > 7
   > 8
   > 9
   > EOF
   $ touch b
   $ hg add a b
   $ hg commit -m "initial commit"
   $ cd ..
 
   $ hg init base-exec
   $ cd base-exec
   $ cat << EOF > a
   > 1
   > 2
   > 3
   > 4
   > 5
   > 6
   > 7
   > 8
   > 9
   > EOF
   $ chmod +x a
   $ touch b
   $ hg add a b
   $ hg commit -m "initial commit"
   $ cd ..
 
 Testing merging mode change
 ===========================
 
 Adding the flag
 ---------------
 
 setup
 
 Change on one side, executable bit on the other
 
   $ hg clone base-repo simple-merge-repo
   updating to branch default
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd simple-merge-repo
   $ chmod +x a
   $ hg ci -m "make a executable, no change"
   $ [ -x a ] || echo "executable bit not recorded"
   $ hg up ".^"
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cat << EOF > a
   > 1
   > 2
   > 3
   > 4
   > 5
   > 6
   > 7
   > x
   > 9
   > EOF
   $ hg commit -m "edit end of file"
   created new head
 
 merge them (from the update side)
 
   $ hg merge 'desc("make a executable, no change")'
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg st
   M a
   $ [ -x a ] || echo "executable bit lost"
 
 merge them (from the chmod side)
 
   $ hg up -C 'desc("make a executable, no change")'
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg merge 'desc("edit end of file")'
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg st
   M a
   $ [ -x a ] || echo "executable bit lost"
 
 
   $ cd ..
 
 
 Removing the flag
 -----------------
 
 Change on one side, executable bit on the other
 
   $ hg clone base-exec simple-merge-repo-removal
   updating to branch default
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd simple-merge-repo-removal
   $ chmod -x a
   $ hg ci -m "make a non-executable, no change"
   $ [ -x a ] && echo "executable bit not removed"
   [1]
   $ hg up ".^"
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cat << EOF > a
   > 1
   > 2
   > 3
   > 4
   > 5
   > 6
   > 7
   > x
   > 9
   > EOF
   $ hg commit -m "edit end of file"
   created new head
 
 merge them (from the update side)
 
   $ hg merge 'desc("make a non-executable, no change")'
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg st
   M a
   $ [ -x a ] && echo "executable bit not removed"
   [1]
 
 merge them (from the chmod side)
 
   $ hg up -C 'desc("make a non-executable, no change")'
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg merge 'desc("edit end of file")'
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg st
   M a
   $ [ -x a ] && echo "executable bit not removed"
   [1]
 
 
   $ cd ..
 
 Testing merging mode change with rename
 =======================================
 
 Adding the flag
 ---------------
 
   $ hg clone base-repo rename-merge-repo
   updating to branch default
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd rename-merge-repo
 
 make "a" executable on one side
 
   $ chmod +x a
   $ hg status
   M a
   $ hg ci -m "make a executable"
   $ [ -x a ] || echo "executable bit not recorded"
   $ hg up ".^"
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 make "a" renamed on the other side
 
   $ hg mv a z
   $ hg st --copies
   A z
     a
   R a
   $ hg ci -m "rename a to z"
   created new head
 
 merge them (from the rename side)
 
   $ hg merge 'desc("make a executable")'
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg st --copies
   M z
     a
   $ [ -x z ] || echo "executable bit lost"
 
 merge them (from the chmod side)
 
   $ hg up -C 'desc("make a executable")'
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg merge 'desc("rename a to z")'
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg st --copies
   M z
     a
   R a
   $ [ -x z ] || echo "executable bit lost"
 
 
   $ cd ..
 
 Removing the flag
 -----------------
 
   $ hg clone base-exec rename-merge-repo-removal
   updating to branch default
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd rename-merge-repo-removal
 
 make "a" non-executable on one side
 
   $ chmod -x a
   $ hg status
   M a
   $ hg ci -m "make a non-executable"
   $ [ -x a ] && echo "executable bit not removed"
   [1]
   $ hg up ".^"
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 make "a" renamed on the other side
 
   $ hg mv a z
   $ hg st --copies
   A z
     a
   R a
   $ hg ci -m "rename a to z"
   created new head
 
 merge them (from the rename side)
 
   $ hg merge 'desc("make a non-executable")'
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg st --copies
   M z
     a
   $ [ -x z ] && echo "executable bit not removed"
   [1]
 
 merge them (from the chmod side)
 
   $ hg up -C 'desc("make a non-executable")'
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg merge 'desc("rename a to z")'
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg st --copies
   M z
     a
   R a
   $ [ -x z ] && echo "executable bit not removed"
   [1]
 
 
   $ cd ..
 
 
 Testing merging mode change with rename + modification on both side
 ===================================================================
 
 
 Adding the flag
 ---------------
 
   $ hg clone base-repo rename+mod-merge-repo
   updating to branch default
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd rename+mod-merge-repo
 
 make "a" executable on one side
 
   $ chmod +x a
   $ cat << EOF > a
   > 1
   > x
   > 3
   > 4
   > 5
   > 6
   > 7
   > 8
   > 9
   > EOF
   $ hg status
   M a
   $ hg ci -m "make a executable, and change start"
   $ [ -x a ] || echo "executable bit not recorded"
   $ hg up ".^"
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 make "a" renamed on the other side
 
   $ hg mv a z
   $ hg st --copies
   A z
     a
   R a
   $ cat << EOF > z
   > 1
   > 2
   > 3
   > 4
   > 5
   > 6
   > 7
   > x
   > 9
   > EOF
   $ hg ci -m "rename a to z, and change end"
   created new head
 
 merge them (from the rename side)
 
   $ hg merge 'desc("make a executable")'
   merging z and a to z
   0 files updated, 1 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg st --copies
   M z
     a
   $ [ -x z ] || echo "executable bit lost"
 
 merge them (from the chmod side)
 
   $ hg up -C 'desc("make a executable")'
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg merge 'desc("rename a to z")'
   merging a and z to z
   0 files updated, 1 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg st --copies
   M z
     a
   R a
   $ [ -x z ] || echo "executable bit lost"
 
   $ cd ..
 
 Removing the flag
 -----------------
 
   $ hg clone base-exec rename+mod-merge-repo-removal
   updating to branch default
   2 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ cd rename+mod-merge-repo-removal
 
 make "a" non-executable on one side
 
   $ chmod -x a
   $ cat << EOF > a
   > 1
   > x
   > 3
   > 4
   > 5
   > 6
   > 7
   > 8
   > 9
   > EOF
   $ hg status
   M a
   $ hg ci -m "make a non-executable, and change start"
   $ [ -x z ] && echo "executable bit not removed"
   [1]
   $ hg up ".^"
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 make "a" renamed on the other side
 
   $ hg mv a z
   $ hg st --copies
   A z
     a
   R a
   $ cat << EOF > z
   > 1
   > 2
   > 3
   > 4
   > 5
   > 6
   > 7
   > x
   > 9
   > EOF
   $ hg ci -m "rename a to z, and change end"
   created new head
 
 merge them (from the rename side)
 
   $ hg merge 'desc("make a non-executable")'
   merging z and a to z
   0 files updated, 1 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg st --copies
   M z
     a
   $ [ -x z ] && echo "executable bit not removed"
   [1]
 
 merge them (from the chmod side)
 
   $ hg up -C 'desc("make a non-executable")'
   1 files updated, 0 files merged, 1 files removed, 0 files unresolved
   $ hg merge 'desc("rename a to z")'
   merging a and z to z
   0 files updated, 1 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ hg st --copies
   M z
     a
   R a
   $ [ -x z ] && echo "executable bit not removed"
   [1]
 
   $ cd ..

tests/test-merge-types.t

@@ -1,476 +1,472 b''
 #require symlink execbit
 
-TODO: fix rhg bugs that make this test fail when status is enabled
-  $ unset RHG_STATUS
-
-
   $ tellmeabout() {
   > if [ -h $1 ]; then
   >     echo $1 is a symlink:
   >     $TESTDIR/readlink.py $1
   > elif [ -x $1 ]; then
   >     echo $1 is an executable file with content:
   >     cat $1
   > else
   >     echo $1 is a plain file with content:
   >     cat $1
   > fi
   > }
 
   $ hg init test1
   $ cd test1
 
   $ echo a > a
   $ hg ci -Aqmadd
   $ chmod +x a
   $ hg ci -mexecutable
 
   $ hg up -q 0
   $ rm a
   $ ln -s symlink a
   $ hg ci -msymlink
   created new head
 
 Symlink is local parent, executable is other:
 
   $ hg merge --debug
   resolving manifests
    branchmerge: True, force: False, partial: False
    ancestor: c334dc3be0da, local: 521a1e40188f+, remote: 3574f3e69b1c
    preserving a for resolve of a
    a: versions differ -> m (premerge)
   tool internal:merge (for pattern a) can't handle symlinks
   couldn't find merge tool hgmerge
   no tool found to merge a
   picked tool ':prompt' for a (binary False symlink True changedelete False)
   file 'a' needs to be resolved.
   You can keep (l)ocal [working copy], take (o)ther [merge rev], or leave (u)nresolved.
   What do you want to do? u
   0 files updated, 0 files merged, 0 files removed, 1 files unresolved
   use 'hg resolve' to retry unresolved file merges or 'hg merge --abort' to abandon
   [1]
 
   $ tellmeabout a
   a is a symlink:
   a -> symlink
   $ hg resolve a --tool internal:other
   (no more unresolved files)
   $ tellmeabout a
   a is an executable file with content:
   a
   $ hg st
   M a
   ? a.orig
 
 Symlink is other parent, executable is local:
 
   $ hg update -C 1
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
   $ hg merge --debug --tool :union
   resolving manifests
    branchmerge: True, force: False, partial: False
    ancestor: c334dc3be0da, local: 3574f3e69b1c+, remote: 521a1e40188f
    preserving a for resolve of a
    a: versions differ -> m (premerge)
   picked tool ':union' for a (binary False symlink True changedelete False)
   merging a
   my a@3574f3e69b1c+ other a@521a1e40188f ancestor a@c334dc3be0da
   warning: internal :union cannot merge symlinks for a
   warning: conflicts while merging a! (edit, then use 'hg resolve --mark')
   0 files updated, 0 files merged, 0 files removed, 1 files unresolved
   use 'hg resolve' to retry unresolved file merges or 'hg merge --abort' to abandon
   [1]
 
   $ tellmeabout a
   a is an executable file with content:
   a
 
   $ hg update -C 1
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
   $ hg merge --debug --tool :merge3
   resolving manifests
    branchmerge: True, force: False, partial: False
    ancestor: c334dc3be0da, local: 3574f3e69b1c+, remote: 521a1e40188f
    preserving a for resolve of a
    a: versions differ -> m (premerge)
   picked tool ':merge3' for a (binary False symlink True changedelete False)
   merging a
   my a@3574f3e69b1c+ other a@521a1e40188f ancestor a@c334dc3be0da
   warning: internal :merge3 cannot merge symlinks for a
   warning: conflicts while merging a! (edit, then use 'hg resolve --mark')
   0 files updated, 0 files merged, 0 files removed, 1 files unresolved
   use 'hg resolve' to retry unresolved file merges or 'hg merge --abort' to abandon
   [1]
 
   $ tellmeabout a
   a is an executable file with content:
   a
 
   $ hg update -C 1
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
   $ hg merge --debug --tool :merge-local
   resolving manifests
    branchmerge: True, force: False, partial: False
    ancestor: c334dc3be0da, local: 3574f3e69b1c+, remote: 521a1e40188f
    preserving a for resolve of a
    a: versions differ -> m (premerge)
   picked tool ':merge-local' for a (binary False symlink True changedelete False)
   merging a
   my a@3574f3e69b1c+ other a@521a1e40188f ancestor a@c334dc3be0da
   warning: internal :merge-local cannot merge symlinks for a
   0 files updated, 0 files merged, 0 files removed, 1 files unresolved
   use 'hg resolve' to retry unresolved file merges or 'hg merge --abort' to abandon
   [1]
 
   $ tellmeabout a
   a is an executable file with content:
   a
 
   $ hg update -C 1
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
   $ hg merge --debug --tool :merge-other
   resolving manifests
    branchmerge: True, force: False, partial: False
    ancestor: c334dc3be0da, local: 3574f3e69b1c+, remote: 521a1e40188f
    preserving a for resolve of a
    a: versions differ -> m (premerge)
   picked tool ':merge-other' for a (binary False symlink True changedelete False)
   merging a
   my a@3574f3e69b1c+ other a@521a1e40188f ancestor a@c334dc3be0da
   warning: internal :merge-other cannot merge symlinks for a
   0 files updated, 0 files merged, 0 files removed, 1 files unresolved
   use 'hg resolve' to retry unresolved file merges or 'hg merge --abort' to abandon
   [1]
 
   $ tellmeabout a
   a is an executable file with content:
   a
 
 Update to link without local change should get us a symlink (issue3316):
 
   $ hg up -C 0
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ hg up
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   updated to "521a1e40188f: symlink"
   1 other heads for branch "default"
   $ hg st
   ? a.orig
 
 Update to link with local change should cause a merge prompt (issue3200):
 
   $ hg up -Cq 0
   $ echo data > a
   $ HGMERGE= hg up -y --debug --config ui.merge=
   resolving manifests
    branchmerge: False, force: False, partial: False
    ancestor: c334dc3be0da, local: c334dc3be0da+, remote: 521a1e40188f
    preserving a for resolve of a
    a: versions differ -> m (premerge)
   (couldn't find merge tool hgmerge|tool hgmerge can't handle symlinks) (re)
   no tool found to merge a
   picked tool ':prompt' for a (binary False symlink True changedelete False)
   file 'a' needs to be resolved.
   You can keep (l)ocal [working copy], take (o)ther [destination], or leave (u)nresolved.
   What do you want to do? u
   0 files updated, 0 files merged, 0 files removed, 1 files unresolved
   use 'hg resolve' to retry unresolved file merges
   updated to "521a1e40188f: symlink"
   1 other heads for branch "default"
   [1]
   $ hg diff --git
   diff --git a/a b/a
   old mode 120000
   new mode 100644
   --- a/a
   +++ b/a
   @@ -1,1 +1,1 @@
   -symlink
   \ No newline at end of file
   +data
 
 
 Test only 'l' change - happens rarely, except when recovering from situations
 where that was what happened.
 
   $ hg init test2
   $ cd test2
   $ printf base > f
   $ hg ci -Aqm0
   $ echo file > f
   $ echo content >> f
   $ hg ci -qm1
   $ hg up -qr0
   $ rm f
   $ ln -s base f
   $ hg ci -qm2
   $ hg merge
   tool internal:merge (for pattern f) can't handle symlinks
   no tool found to merge f
   file 'f' needs to be resolved.
   You can keep (l)ocal [working copy], take (o)ther [merge rev], or leave (u)nresolved.
   What do you want to do? u
   0 files updated, 0 files merged, 0 files removed, 1 files unresolved
   use 'hg resolve' to retry unresolved file merges or 'hg merge --abort' to abandon
   [1]
   $ tellmeabout f
   f is a symlink:
   f -> base
 
   $ hg up -Cqr1
   $ hg merge
   tool internal:merge (for pattern f) can't handle symlinks
   no tool found to merge f
   file 'f' needs to be resolved.
   You can keep (l)ocal [working copy], take (o)ther [merge rev], or leave (u)nresolved.
   What do you want to do? u
   0 files updated, 0 files merged, 0 files removed, 1 files unresolved
   use 'hg resolve' to retry unresolved file merges or 'hg merge --abort' to abandon
   [1]
   $ tellmeabout f
   f is a plain file with content:
   file
   content
 
   $ cd ..
 
 Test removed 'x' flag merged with change to symlink
 
   $ hg init test3
   $ cd test3
   $ echo f > f
   $ chmod +x f
   $ hg ci -Aqm0
   $ chmod -x f
   $ hg ci -qm1
   $ hg up -qr0
   $ rm f
   $ ln -s dangling f
   $ hg ci -qm2
   $ hg merge
   tool internal:merge (for pattern f) can't handle symlinks
   no tool found to merge f
   file 'f' needs to be resolved.
   You can keep (l)ocal [working copy], take (o)ther [merge rev], or leave (u)nresolved.
   What do you want to do? u
   0 files updated, 0 files merged, 0 files removed, 1 files unresolved
   use 'hg resolve' to retry unresolved file merges or 'hg merge --abort' to abandon
   [1]
   $ tellmeabout f
   f is a symlink:
   f -> dangling
 
   $ hg up -Cqr1
   $ hg merge
   tool internal:merge (for pattern f) can't handle symlinks
   no tool found to merge f
   file 'f' needs to be resolved.
   You can keep (l)ocal [working copy], take (o)ther [merge rev], or leave (u)nresolved.
   What do you want to do? u
   0 files updated, 0 files merged, 0 files removed, 1 files unresolved
   use 'hg resolve' to retry unresolved file merges or 'hg merge --abort' to abandon
   [1]
   $ tellmeabout f
   f is a plain file with content:
   f
 
 Test removed 'x' flag merged with content change - both ways
 
   $ hg up -Cqr0
   $ echo change > f
   $ hg ci -qm3
   $ hg merge -r1
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ tellmeabout f
   f is a plain file with content:
   change
 
   $ hg up -qCr1
   $ hg merge -r3
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
   (branch merge, don't forget to commit)
   $ tellmeabout f
   f is a plain file with content:
   change
 
   $ cd ..
 
 Test merge with no common ancestor:
 a: just different
 b: x vs -, different (cannot calculate x, cannot ask merge tool)
 c: x vs -, same (cannot calculate x, merge tool is no good)
 d: x vs l, different
 e: x vs l, same
 f: - vs l, different
 g: - vs l, same
 h: l vs l, different
 (where same means the filelog entry is shared and there thus is an ancestor!)
 
   $ hg init test4
   $ cd test4
   $ echo 0 > 0
   $ hg ci -Aqm0
 
   $ echo 1 > a
   $ echo 1 > b
   $ chmod +x b
   $ echo 1 > bx
   $ chmod +x bx
   $ echo x > c
   $ chmod +x c
   $ echo 1 > d
   $ chmod +x d
   $ printf x > e
   $ chmod +x e
   $ echo 1 > f
   $ printf x > g
   $ ln -s 1 h
   $ hg ci -qAm1
 
   $ hg up -qr0
   $ echo 2 > a
   $ echo 2 > b
   $ echo 2 > bx
   $ chmod +x bx
   $ echo x > c
   $ ln -s 2 d
   $ ln -s x e
   $ ln -s 2 f
   $ ln -s x g
   $ ln -s 2 h
   $ hg ci -Aqm2
 
   $ hg merge
   merging a
   warning: cannot merge flags for b without common ancestor - keeping local flags
   merging b
   merging bx
   warning: cannot merge flags for c without common ancestor - keeping local flags
   tool internal:merge (for pattern d) can't handle symlinks
   no tool found to merge d
   file 'd' needs to be resolved.
   You can keep (l)ocal [working copy], take (o)ther [merge rev], or leave (u)nresolved.
   What do you want to do? u
   tool internal:merge (for pattern f) can't handle symlinks
   no tool found to merge f
   file 'f' needs to be resolved.
   You can keep (l)ocal [working copy], take (o)ther [merge rev], or leave (u)nresolved.
   What do you want to do? u
   tool internal:merge (for pattern h) can't handle symlinks
   no tool found to merge h
   file 'h' needs to be resolved.
   You can keep (l)ocal [working copy], take (o)ther [merge rev], or leave (u)nresolved.
   What do you want to do? u
   warning: conflicts while merging a! (edit, then use 'hg resolve --mark')
   warning: conflicts while merging b! (edit, then use 'hg resolve --mark')
   warning: conflicts while merging bx! (edit, then use 'hg resolve --mark')
   3 files updated, 0 files merged, 0 files removed, 6 files unresolved
   use 'hg resolve' to retry unresolved file merges or 'hg merge --abort' to abandon
   [1]
   $ hg resolve -l
   U a
   U b
   U bx
   U d
   U f
   U h
   $ tellmeabout a
   a is a plain file with content:
   <<<<<<< working copy: 0c617753b41b - test: 2
   2
   =======
   1
   >>>>>>> merge rev:    2e60aa20b912 - test: 1
   $ tellmeabout b
   b is a plain file with content:
   <<<<<<< working copy: 0c617753b41b - test: 2
   2
   =======
   1
   >>>>>>> merge rev:    2e60aa20b912 - test: 1
   $ tellmeabout c
   c is a plain file with content:
   x
   $ tellmeabout d
   d is a symlink:
   d -> 2
   $ tellmeabout e
   e is a symlink:
   e -> x
   $ tellmeabout f
   f is a symlink:
   f -> 2
   $ tellmeabout g
   g is a symlink:
   g -> x
   $ tellmeabout h
   h is a symlink:
   h -> 2
 
   $ hg up -Cqr1
   $ hg merge
   merging a
   warning: cannot merge flags for b without common ancestor - keeping local flags
   merging b
   merging bx
   warning: cannot merge flags for c without common ancestor - keeping local flags
   tool internal:merge (for pattern d) can't handle symlinks
   no tool found to merge d
   file 'd' needs to be resolved.
   You can keep (l)ocal [working copy], take (o)ther [merge rev], or leave (u)nresolved.
   What do you want to do? u
   tool internal:merge (for pattern f) can't handle symlinks
   no tool found to merge f
   file 'f' needs to be resolved.
   You can keep (l)ocal [working copy], take (o)ther [merge rev], or leave (u)nresolved.
   What do you want to do? u
   tool internal:merge (for pattern h) can't handle symlinks
   no tool found to merge h
   file 'h' needs to be resolved.
   You can keep (l)ocal [working copy], take (o)ther [merge rev], or leave (u)nresolved.
   What do you want to do? u
   warning: conflicts while merging a! (edit, then use 'hg resolve --mark')
   warning: conflicts while merging b! (edit, then use 'hg resolve --mark')
   warning: conflicts while merging bx! (edit, then use 'hg resolve --mark')
   3 files updated, 0 files merged, 0 files removed, 6 files unresolved
   use 'hg resolve' to retry unresolved file merges or 'hg merge --abort' to abandon
   [1]
   $ tellmeabout a
   a is a plain file with content:
   <<<<<<< working copy: 2e60aa20b912 - test: 1
   1
   =======
   2
   >>>>>>> merge rev:    0c617753b41b - test: 2
   $ tellmeabout b
   b is an executable file with content:
   <<<<<<< working copy: 2e60aa20b912 - test: 1
   1
   =======
   2
   >>>>>>> merge rev:    0c617753b41b - test: 2
   $ tellmeabout c
   c is an executable file with content:
   x
   $ tellmeabout d
   d is an executable file with content:
   1
   $ tellmeabout e
   e is an executable file with content:
   x (no-eol)
   $ tellmeabout f
   f is a plain file with content:
   1
   $ tellmeabout g
   g is a plain file with content:
   x (no-eol)
   $ tellmeabout h
   h is a symlink:
   h -> 1
 
   $ cd ..

tests/test-symlinks.t

@@ -1,290 +1,286 b''
 #require symlink
 
 #testcases dirstate-v1 dirstate-v2
 
 #if dirstate-v2
   $ cat >> $HGRCPATH << EOF
   > [format]
   > exp-rc-dirstate-v2=1
   > [storage]
   > dirstate-v2.slow-path=allow
   > EOF
 #endif
 
-TODO: fix rhg bugs that make this test fail when status is enabled
-  $ unset RHG_STATUS
-
-
 == tests added in 0.7 ==
 
   $ hg init test-symlinks-0.7; cd test-symlinks-0.7;
   $ touch foo; ln -s foo bar; ln -s nonexistent baz
 
 import with add and addremove -- symlink walking should _not_ screwup.
 
   $ hg add
   adding bar
   adding baz
   adding foo
   $ hg forget bar baz foo
   $ hg addremove
   adding bar
   adding baz
   adding foo
 
 commit -- the symlink should _not_ appear added to dir state
 
   $ hg commit -m 'initial'
 
   $ touch bomb
 
 again, symlink should _not_ show up on dir state
 
   $ hg addremove
   adding bomb
 
 Assert screamed here before, should go by without consequence
 
   $ hg commit -m 'is there a bug?'
   $ cd ..
 
 
 == fifo & ignore ==
 
   $ hg init test; cd test;
 
   $ mkdir dir
   $ touch a.c dir/a.o dir/b.o
 
 test what happens if we want to trick hg
 
   $ hg commit -A -m 0
   adding a.c
   adding dir/a.o
   adding dir/b.o
   $ echo "relglob:*.o" > .hgignore
   $ rm a.c
   $ rm dir/a.o
   $ rm dir/b.o
   $ mkdir dir/a.o
   $ ln -s nonexistent dir/b.o
   $ mkfifo a.c
 
 it should show a.c, dir/a.o and dir/b.o deleted
 
   $ hg status
   M dir/b.o
   ! a.c
   ! dir/a.o
   ? .hgignore
   $ hg status a.c
   a.c: unsupported file type (type is fifo)
   ! a.c
   $ cd ..
 
 
 == symlinks from outside the tree ==
 
 test absolute path through symlink outside repo
 
   $ p=`pwd`
   $ hg init x
   $ ln -s x y
   $ cd x
   $ touch f
   $ hg add f
   $ hg status "$p"/y/f
   A f
 
 try symlink outside repo to file inside
 
   $ ln -s x/f ../z
 
 this should fail
 
   $ hg status ../z && { echo hg mistakenly exited with status 0; exit 1; } || :
   abort: ../z not under root '$TESTTMP/x'
   $ cd ..
 
 
 == cloning symlinks ==
   $ hg init clone; cd clone;
 
 try cloning symlink in a subdir
 1. commit a symlink
 
   $ mkdir -p a/b/c
   $ cd a/b/c
   $ ln -s /path/to/symlink/source demo
   $ cd ../../..
   $ hg stat
   ? a/b/c/demo
   $ hg commit -A -m 'add symlink in a/b/c subdir'
   adding a/b/c/demo
 
 2. clone it
 
   $ cd ..
   $ hg clone clone clonedest
   updating to branch default
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 
 == symlink and git diffs ==
 
 git symlink diff
 
   $ cd clonedest
   $ hg diff --git -r null:tip
   diff --git a/a/b/c/demo b/a/b/c/demo
   new file mode 120000
   --- /dev/null
   +++ b/a/b/c/demo
   @@ -0,0 +1,1 @@
   +/path/to/symlink/source
   \ No newline at end of file
   $ hg export --git tip > ../sl.diff
 
 import git symlink diff
 
   $ hg rm a/b/c/demo
   $ hg commit -m'remove link'
   $ hg import ../sl.diff
   applying ../sl.diff
   $ hg diff --git -r 1:tip
   diff --git a/a/b/c/demo b/a/b/c/demo
   new file mode 120000
   --- /dev/null
   +++ b/a/b/c/demo
   @@ -0,0 +1,1 @@
   +/path/to/symlink/source
   \ No newline at end of file
 
 == symlinks and addremove ==
 
 directory moved and symlinked
 
   $ mkdir foo
   $ touch foo/a
   $ hg ci -Ama
   adding foo/a
   $ mv foo bar
   $ ln -s bar foo
   $ hg status
   ! foo/a
   ? bar/a
   ? foo
 
 now addremove should remove old files
 
   $ hg addremove
   adding bar/a
   adding foo
   removing foo/a
 
 commit and update back
 
   $ hg ci -mb
   $ hg up '.^'
   1 files updated, 0 files merged, 2 files removed, 0 files unresolved
   $ hg up tip
   2 files updated, 0 files merged, 1 files removed, 0 files unresolved
 
   $ cd ..
 
 == root of repository is symlinked ==
 
   $ hg init root
   $ ln -s root link
   $ cd root
   $ echo foo > foo
   $ hg status
   ? foo
   $ hg status ../link
   ? foo
   $ hg add foo
   $ hg cp foo "$TESTTMP/link/bar"
   foo has not been committed yet, so no copy data will be stored for bar.
   $ cd ..
 
 
   $ hg init b
   $ cd b
   $ ln -s nothing dangling
   $ hg commit -m 'commit symlink without adding' dangling
   abort: dangling: file not tracked!
   [10]
   $ hg add dangling
   $ hg commit -m 'add symlink'
 
   $ hg tip -v
   changeset:   0:cabd88b706fc
   tag:         tip
   user:        test
   date:        Thu Jan 01 00:00:00 1970 +0000
   files:       dangling
   description:
   add symlink
   
   
   $ hg manifest --debug
   2564acbe54bbbedfbf608479340b359f04597f80 644 @ dangling
   $ readlink.py dangling
   dangling -> nothing
 
   $ rm dangling
   $ ln -s void dangling
   $ hg commit -m 'change symlink'
   $ readlink.py dangling
   dangling -> void
 
 
 modifying link
 
   $ rm dangling
   $ ln -s empty dangling
   $ readlink.py dangling
   dangling -> empty
 
 
 reverting to rev 0:
 
   $ hg revert -r 0 -a
   reverting dangling
   $ readlink.py dangling
   dangling -> nothing
 
 
 backups:
 
   $ readlink.py *.orig
   dangling.orig -> empty
   $ rm *.orig
   $ hg up -C
   1 files updated, 0 files merged, 0 files removed, 0 files unresolved
 
 copies
 
   $ hg cp -v dangling dangling2
   copying dangling to dangling2
   $ hg st -Cmard
   A dangling2
     dangling
   $ readlink.py dangling dangling2
   dangling -> void
   dangling2 -> void
 
 
 Issue995: hg copy -A incorrectly handles symbolic links
 
   $ hg up -C
   0 files updated, 0 files merged, 0 files removed, 0 files unresolved
   $ mkdir dir
   $ ln -s dir dirlink
   $ hg ci -qAm 'add dirlink'
   $ mkdir newdir
   $ mv dir newdir/dir
   $ mv dirlink newdir/dirlink
   $ hg mv -A dirlink newdir/dirlink
 
   $ cd ..