This is an archive of the discontinued Mercurial Phabricator instance.

Differential D11461

rust: Make the fields of DirstateEntry private
ClosedPublic

Authored by SimonSapin on Sep 20 2021, 6:16 PM.

Details

Reviewers
Alphare
Group Reviewers
hg-reviewers
Commits
rHGf2a9db29cb2d: rust: Make the fields of DirstateEntry private
Summary

This is a first step toward making its internal structure equivalent to
Python’s DirstateItem.

Diff Detail

Repository
rHG Mercurial
Lint
Automatic diff as part of commit; lint not applicable.
Unit
Automatic diff as part of commit; unit tests not applicable.

Event Timeline

SimonSapin created this revision.Sep 20 2021, 6:16 PM
Alphare accepted this revision.Sep 22 2021, 4:04 AM
This revision is now accepted and ready to land.Sep 22 2021, 4:04 AM
SimonSapin added a commit: rHGf2a9db29cb2d: rust: Make the fields of DirstateEntry private.Sep 22 2021, 4:54 AM
Closed by commit rHGf2a9db29cb2d: rust: Make the fields of DirstateEntry private (authored by SimonSapin). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 30373

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

let mut multiset = DirsMultiset { let mut multiset = DirsMultiset {
inner: FastHashMap::default(), inner: FastHashMap::default(),
}; };
for item in dirstate { for item in dirstate {
let (filename, entry) = item?; let (filename, entry) = item?;
let filename = filename.as_ref(); let filename = filename.as_ref();
// This `if` is optimized out of the loop // This `if` is optimized out of the loop
if only_tracked { if only_tracked {
if entry.state != EntryState::Removed { if entry.state() != EntryState::Removed {
multiset.add_path(filename)?; multiset.add_path(filename)?;
} }
} else { } else {
multiset.add_path(filename)?; multiset.add_path(filename)?;
} }
} }
Ok(multiset) Ok(multiset)
let expected = DirsMultiset { let expected = DirsMultiset {
inner: expected_inner, inner: expected_inner,
}; };
assert_eq!(expected, new); assert_eq!(expected, new);
let input_map = ["b/x", "a/c", "a/d/x"].iter().map(|f| { let input_map = ["b/x", "a/c", "a/d/x"].iter().map(|f| {
Ok(( Ok((
HgPathBuf::from_bytes(f.as_bytes()), HgPathBuf::from_bytes(f.as_bytes()),
DirstateEntry { DirstateEntry::from_v1_data(EntryState::Normal, 0, 0, 0),
state: EntryState::Normal,
mode: 0,
mtime: 0,
size: 0,
},
)) ))
}); });
let expected_inner = [("", 2), ("a", 2), ("b", 1), ("a/d", 1)] let expected_inner = [("", 2), ("a", 2), ("b", 1), ("a/d", 1)]
.iter() .iter()
.map(|(k, v)| (HgPathBuf::from_bytes(k.as_bytes()), *v)) .map(|(k, v)| (HgPathBuf::from_bytes(k.as_bytes()), *v))
.collect(); .collect();
let new = DirsMultiset::from_dirstate(input_map, false).unwrap(); let new = DirsMultiset::from_dirstate(input_map, false).unwrap();
("a/b", EntryState::Normal), ("a/b", EntryState::Normal),
("a/c", EntryState::Removed), ("a/c", EntryState::Removed),
("a/d", EntryState::Merged), ("a/d", EntryState::Merged),
] ]
.iter() .iter()
.map(|(f, state)| { .map(|(f, state)| {
Ok(( Ok((
HgPathBuf::from_bytes(f.as_bytes()), HgPathBuf::from_bytes(f.as_bytes()),
DirstateEntry { DirstateEntry::from_v1_data(*state, 0, 0, 0),
state: *state,
mode: 0,
mtime: 0,
size: 0,
},
)) ))
}); });
// "a" incremented with "a/c" and "a/d/" // "a" incremented with "a/c" and "a/d/"
let expected_inner = [("", 1), ("a", 3)] let expected_inner = [("", 1), ("a", 3)]
.iter() .iter()
.map(|(k, v)| (HgPathBuf::from_bytes(k.as_bytes()), *v)) .map(|(k, v)| (HgPathBuf::from_bytes(k.as_bytes()), *v))
.collect(); .collect();
let new = DirsMultiset::from_dirstate(input_map, true).unwrap(); let new = DirsMultiset::from_dirstate(input_map, true).unwrap();
let expected = DirsMultiset { let expected = DirsMultiset {
inner: expected_inner, inner: expected_inner,
}; };
assert_eq!(expected, new); assert_eq!(expected, new);
} }
} }

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

filename: &HgPath, filename: &HgPath,
entry: DirstateEntry, entry: DirstateEntry,
// XXX once the dust settle this should probably become an enum // XXX once the dust settle this should probably become an enum
added: bool, added: bool,
merged: bool, merged: bool,
from_p2: bool, from_p2: bool,
possibly_dirty: bool, possibly_dirty: bool,
) -> Result<(), DirstateError> { ) -> Result<(), DirstateError> {
let mut entry = entry; let state;
let size;
let mtime;
if added { if added {
assert!(!merged);
assert!(!possibly_dirty); assert!(!possibly_dirty);
assert!(!from_p2); assert!(!from_p2);
entry.state = EntryState::Added; state = EntryState::Added;
entry.size = SIZE_NON_NORMAL; size = SIZE_NON_NORMAL;
entry.mtime = MTIME_UNSET; mtime = MTIME_UNSET;
} else if merged { } else if merged {
assert!(!possibly_dirty); assert!(!possibly_dirty);
assert!(!from_p2); assert!(!from_p2);
entry.state = EntryState::Merged; state = EntryState::Merged;
entry.size = SIZE_FROM_OTHER_PARENT; size = SIZE_FROM_OTHER_PARENT;
entry.mtime = MTIME_UNSET; mtime = MTIME_UNSET;
} else if from_p2 { } else if from_p2 {
assert!(!possibly_dirty); assert!(!possibly_dirty);
entry.state = EntryState::Normal; state = EntryState::Normal;
entry.size = SIZE_FROM_OTHER_PARENT; size = SIZE_FROM_OTHER_PARENT;
entry.mtime = MTIME_UNSET; mtime = MTIME_UNSET;
} else if possibly_dirty { } else if possibly_dirty {
entry.state = EntryState::Normal; state = EntryState::Normal;
entry.size = SIZE_NON_NORMAL; size = SIZE_NON_NORMAL;
entry.mtime = MTIME_UNSET; mtime = MTIME_UNSET;
} else { } else {
entry.state = EntryState::Normal; state = EntryState::Normal;
entry.size = entry.size & V1_RANGEMASK; size = entry.size() & V1_RANGEMASK;
entry.mtime = entry.mtime & V1_RANGEMASK; mtime = entry.mtime() & V1_RANGEMASK;
} }
let mode = entry.mode();
let entry = DirstateEntry::from_v1_data(state, mode, size, mtime);
let old_state = match self.get(filename) { let old_state = match self.get(filename) {
Some(e) => e.state, Some(e) => e.state(),
None => EntryState::Unknown, None => EntryState::Unknown,
}; };
if old_state == EntryState::Unknown || old_state == EntryState::Removed if old_state == EntryState::Unknown || old_state == EntryState::Removed
{ {
if let Some(ref mut dirs) = self.dirs { if let Some(ref mut dirs) = self.dirs {
dirs.add_path(filename)?; dirs.add_path(filename)?;
} }
} }
/// to be more explicit about what that state is. /// to be more explicit about what that state is.
pub fn remove_file( pub fn remove_file(
&mut self, &mut self,
filename: &HgPath, filename: &HgPath,
in_merge: bool, in_merge: bool,
) -> Result<(), DirstateError> { ) -> Result<(), DirstateError> {
let old_entry_opt = self.get(filename); let old_entry_opt = self.get(filename);
let old_state = match old_entry_opt { let old_state = match old_entry_opt {
Some(e) => e.state, Some(e) => e.state(),
None => EntryState::Unknown, None => EntryState::Unknown,
}; };
let mut size = 0; let mut size = 0;
if in_merge { if in_merge {
// XXX we should not be able to have 'm' state and 'FROM_P2' if not // XXX we should not be able to have 'm' state and 'FROM_P2' if not
// during a merge. So I (marmoute) am not sure we need the // during a merge. So I (marmoute) am not sure we need the
// conditionnal at all. Adding double checking this with assert // conditionnal at all. Adding double checking this with assert
// would be nice. // would be nice.
if let Some(old_entry) = old_entry_opt { if let Some(old_entry) = old_entry_opt {
// backup the previous state // backup the previous state
if old_entry.state == EntryState::Merged { if old_entry.state() == EntryState::Merged {
size = SIZE_NON_NORMAL; size = SIZE_NON_NORMAL;
} else if old_entry.state == EntryState::Normal } else if old_entry.state() == EntryState::Normal
&& old_entry.size == SIZE_FROM_OTHER_PARENT && old_entry.size() == SIZE_FROM_OTHER_PARENT
{ {
// other parent // other parent
size = SIZE_FROM_OTHER_PARENT; size = SIZE_FROM_OTHER_PARENT;
self.get_non_normal_other_parent_entries() self.get_non_normal_other_parent_entries()
.1 .1
.insert(filename.to_owned()); .insert(filename.to_owned());
} }
} }
} }
if old_state != EntryState::Unknown && old_state != EntryState::Removed if old_state != EntryState::Unknown && old_state != EntryState::Removed
{ {
if let Some(ref mut dirs) = self.dirs { if let Some(ref mut dirs) = self.dirs {
dirs.delete_path(filename)?; dirs.delete_path(filename)?;
} }
} }
if old_state == EntryState::Unknown { if old_state == EntryState::Unknown {
if let Some(ref mut all_dirs) = self.all_dirs { if let Some(ref mut all_dirs) = self.all_dirs {
all_dirs.add_path(filename)?; all_dirs.add_path(filename)?;
} }
} }
if size == 0 { if size == 0 {
self.copy_map.remove(filename); self.copy_map.remove(filename);
} }
self.state_map.insert( self.state_map
filename.to_owned(), .insert(filename.to_owned(), DirstateEntry::new_removed(size));
DirstateEntry {
state: EntryState::Removed,
mode: 0,
size,
mtime: 0,
},
);
self.get_non_normal_other_parent_entries() self.get_non_normal_other_parent_entries()
.0 .0
.insert(filename.to_owned()); .insert(filename.to_owned());
Ok(()) Ok(())
} }
/// Remove a file from the dirstate. /// Remove a file from the dirstate.
/// Returns `true` if the file was previously recorded. /// Returns `true` if the file was previously recorded.
pub fn drop_file( pub fn drop_file(
&mut self, &mut self,
filename: &HgPath, filename: &HgPath,
) -> Result<bool, DirstateError> { ) -> Result<bool, DirstateError> {
let old_state = match self.get(filename) { let old_state = match self.get(filename) {
Some(e) => e.state, Some(e) => e.state(),
None => EntryState::Unknown, None => EntryState::Unknown,
}; };
let exists = self.state_map.remove(filename).is_some(); let exists = self.state_map.remove(filename).is_some();
if exists { if exists {
if old_state != EntryState::Removed { if old_state != EntryState::Removed {
if let Some(ref mut dirs) = self.dirs { if let Some(ref mut dirs) = self.dirs {
dirs.delete_path(filename)?; dirs.delete_path(filename)?;
#[test] #[test]
fn test_add_file() { fn test_add_file() {
let mut map = DirstateMap::new(); let mut map = DirstateMap::new();
assert_eq!(0, map.len()); assert_eq!(0, map.len());
map.add_file( map.add_file(
HgPath::new(b"meh"), HgPath::new(b"meh"),
DirstateEntry { DirstateEntry::from_v1_data(EntryState::Normal, 1337, 1337, 1337),
state: EntryState::Normal,
mode: 1337,
mtime: 1337,
size: 1337,
},
false, false,
false, false,
false, false,
false, false,
) )
.unwrap(); .unwrap();
assert_eq!(1, map.len()); assert_eq!(1, map.len());
(b"f9", (EntryState::Merged, 1337, -2, 1337)), (b"f9", (EntryState::Merged, 1337, -2, 1337)),
(b"fa", (EntryState::Added, 1337, -2, 1337)), (b"fa", (EntryState::Added, 1337, -2, 1337)),
(b"fb", (EntryState::Removed, 1337, -2, 1337)), (b"fb", (EntryState::Removed, 1337, -2, 1337)),
] ]
.iter() .iter()
.map(|(fname, (state, mode, size, mtime))| { .map(|(fname, (state, mode, size, mtime))| {
( (
HgPathBuf::from_bytes(fname.as_ref()), HgPathBuf::from_bytes(fname.as_ref()),
DirstateEntry { DirstateEntry::from_v1_data(*state, *mode, *size, *mtime),
state: *state,
mode: *mode,
size: *size,
mtime: *mtime,
},
) )
}) })
.collect(); .collect();
let mut non_normal = [ let mut non_normal = [
b"f1", b"f2", b"f5", b"f6", b"f7", b"f8", b"f9", b"fa", b"fb", b"f1", b"f2", b"f5", b"f6", b"f7", b"f8", b"f9", b"fa", b"fb",
] ]
.iter() .iter()

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

Unknown, Unknown,
} }
/// The C implementation uses all signed types. This will be an issue /// The C implementation uses all signed types. This will be an issue
/// either when 4GB+ source files are commonplace or in 2038, whichever /// either when 4GB+ source files are commonplace or in 2038, whichever
/// comes first. /// comes first.
#[derive(Debug, PartialEq, Copy, Clone)] #[derive(Debug, PartialEq, Copy, Clone)]
pub struct DirstateEntry { pub struct DirstateEntry {
pub state: EntryState, state: EntryState,
pub mode: i32, mode: i32,
pub mtime: i32, size: i32,
pub size: i32, mtime: i32,
} }
pub const V1_RANGEMASK: i32 = 0x7FFFFFFF; pub const V1_RANGEMASK: i32 = 0x7FFFFFFF;
pub const MTIME_UNSET: i32 = -1; pub const MTIME_UNSET: i32 = -1;
/// A `DirstateEntry` with a size of `-2` means that it was merged from the /// 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 /// other parent. This allows revert to pick the right status back during a
/// merge. /// merge.
pub const SIZE_FROM_OTHER_PARENT: i32 = -2; pub const SIZE_FROM_OTHER_PARENT: i32 = -2;
/// A special value used for internal representation of special case in /// A special value used for internal representation of special case in
/// dirstate v1 format. /// dirstate v1 format.
pub const SIZE_NON_NORMAL: i32 = -1; pub const SIZE_NON_NORMAL: i32 = -1;
impl DirstateEntry { impl DirstateEntry {
pub fn from_v1_data(
state: EntryState,
mode: i32,
size: i32,
mtime: i32,
) -> Self {
Self {
state,
mode,
size,
mtime,
}
}
/// 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 {
state: EntryState::Removed,
mode: 0,
size,
mtime: 0,
}
}
/// TODO: refactor `DirstateMap::add_file` to not take a `DirstateEntry`
/// parameter and remove this constructor
pub fn new_for_add_file(mode: i32, size: i32, mtime: i32) -> Self {
Self {
// XXX Arbitrary default value since the value is determined later
state: EntryState::Normal,
mode,
size,
mtime,
}
}
pub fn state(&self) -> EntryState {
self.state
}
pub fn mode(&self) -> i32 {
self.mode
}
pub fn size(&self) -> i32 {
self.size
}
pub fn mtime(&self) -> i32 {
self.mtime
}
/// 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.state.into(), self.mode, self.size, self.mtime)
}
pub fn is_non_normal(&self) -> bool { pub fn is_non_normal(&self) -> bool {
self.state != EntryState::Normal || self.mtime == MTIME_UNSET self.state != EntryState::Normal || self.mtime == MTIME_UNSET
} }
pub fn is_from_other_parent(&self) -> bool { pub fn is_from_other_parent(&self) -> bool {
self.state == EntryState::Normal && self.size == SIZE_FROM_OTHER_PARENT self.state == EntryState::Normal && self.size == SIZE_FROM_OTHER_PARENT
} }

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

entries.push((path, *entry)); entries.push((path, *entry));
Ok(()) Ok(())
})?; })?;
Ok((parents, entries, copies)) Ok((parents, entries, copies))
} }
#[derive(BytesCast)] #[derive(BytesCast)]
#[repr(C)] #[repr(C)]
pub(super) struct RawEntry { struct RawEntry {
state: u8, state: u8,
mode: unaligned::I32Be, mode: unaligned::I32Be,
size: unaligned::I32Be, size: unaligned::I32Be,
mtime: unaligned::I32Be, mtime: unaligned::I32Be,
length: unaligned::I32Be, length: unaligned::I32Be,
} }
pub fn parse_dirstate_entries<'a>( pub fn parse_dirstate_entries<'a>(
mut contents: &'a [u8], mut contents: &'a [u8],
mut each_entry: impl FnMut( mut each_entry: impl FnMut(
&'a HgPath, &'a HgPath,
&DirstateEntry, &DirstateEntry,
Option<&'a HgPath>, Option<&'a HgPath>,
) -> Result<(), HgError>, ) -> Result<(), HgError>,
) -> Result<&'a DirstateParents, HgError> { ) -> Result<&'a DirstateParents, HgError> {
let (parents, rest) = DirstateParents::from_bytes(contents) let (parents, rest) = DirstateParents::from_bytes(contents)
.map_err(|_| HgError::corrupted("Too little data for dirstate."))?; .map_err(|_| HgError::corrupted("Too little data for dirstate."))?;
contents = rest; contents = rest;
while !contents.is_empty() { while !contents.is_empty() {
let (raw_entry, rest) = RawEntry::from_bytes(contents) let (raw_entry, rest) = RawEntry::from_bytes(contents)
.map_err(|_| HgError::corrupted("Overflow in dirstate."))?; .map_err(|_| HgError::corrupted("Overflow in dirstate."))?;
let entry = DirstateEntry { let entry = DirstateEntry::from_v1_data(
state: EntryState::try_from(raw_entry.state)?, EntryState::try_from(raw_entry.state)?,
mode: raw_entry.mode.get(), raw_entry.mode.get(),
mtime: raw_entry.mtime.get(), raw_entry.size.get(),
size: raw_entry.size.get(), raw_entry.mtime.get(),
}; );
let (paths, rest) = let (paths, rest) =
u8::slice_from_bytes(rest, raw_entry.length.get() as usize) u8::slice_from_bytes(rest, raw_entry.length.get() as usize)
.map_err(|_| HgError::corrupted("Overflow in dirstate."))?; .map_err(|_| HgError::corrupted("Overflow in dirstate."))?;
// `paths` is either a single path, or two paths separated by a NULL // `paths` is either a single path, or two paths separated by a NULL
// byte // byte
let mut iter = paths.splitn(2, |&byte| byte == b'\0'); let mut iter = paths.splitn(2, |&byte| byte == b'\0');
let path = HgPath::new( let path = HgPath::new(
pub fn pack_entry( pub fn pack_entry(
filename: &HgPath, filename: &HgPath,
entry: &DirstateEntry, entry: &DirstateEntry,
copy_source: Option<&HgPath>, copy_source: Option<&HgPath>,
packed: &mut Vec<u8>, packed: &mut Vec<u8>,
) { ) {
let length = packed_filename_and_copy_source_size(filename, copy_source); let length = packed_filename_and_copy_source_size(filename, copy_source);
let (state, mode, size, mtime) = entry.v1_data();
// Unwrapping because `impl std::io::Write for Vec<u8>` never errors // Unwrapping because `impl std::io::Write for Vec<u8>` never errors
packed.write_u8(entry.state.into()).unwrap(); packed.write_u8(state).unwrap();
packed.write_i32::<BigEndian>(entry.mode).unwrap(); packed.write_i32::<BigEndian>(mode).unwrap();
packed.write_i32::<BigEndian>(entry.size).unwrap(); packed.write_i32::<BigEndian>(size).unwrap();
packed.write_i32::<BigEndian>(entry.mtime).unwrap(); packed.write_i32::<BigEndian>(mtime).unwrap();
packed.write_i32::<BigEndian>(length as i32).unwrap(); packed.write_i32::<BigEndian>(length as i32).unwrap();
packed.extend(filename.as_bytes()); packed.extend(filename.as_bytes());
if let Some(source) = copy_source { if let Some(source) = copy_source {
packed.push(b'\0'); packed.push(b'\0');
packed.extend(source.as_bytes()); packed.extend(source.as_bytes());
} }
} }
); );
assert!(state_map.is_empty()) assert!(state_map.is_empty())
} }
#[test] #[test]
fn test_pack_dirstate_one_entry() { fn test_pack_dirstate_one_entry() {
let expected_state_map: StateMap = [( let expected_state_map: StateMap = [(
HgPathBuf::from_bytes(b"f1"), HgPathBuf::from_bytes(b"f1"),
DirstateEntry { DirstateEntry::from_v1_data(
state: EntryState::Normal, EntryState::Normal,
mode: 0o644, 0o644,
size: 0, 0,
mtime: 791231220, 791231220,
}, ),
)] )]
.iter() .iter()
.cloned() .cloned()
.collect(); .collect();
let mut state_map = expected_state_map.clone(); let mut state_map = expected_state_map.clone();
let copymap = FastHashMap::default(); let copymap = FastHashMap::default();
let parents = DirstateParents { let parents = DirstateParents {
); );
assert_eq!(expected_state_map, state_map); assert_eq!(expected_state_map, state_map);
} }
#[test] #[test]
fn test_pack_dirstate_one_entry_with_copy() { fn test_pack_dirstate_one_entry_with_copy() {
let expected_state_map: StateMap = [( let expected_state_map: StateMap = [(
HgPathBuf::from_bytes(b"f1"), HgPathBuf::from_bytes(b"f1"),
DirstateEntry { DirstateEntry::from_v1_data(
state: EntryState::Normal, EntryState::Normal,
mode: 0o644, 0o644,
size: 0, 0,
mtime: 791231220, 791231220,
}, ),
)] )]
.iter() .iter()
.cloned() .cloned()
.collect(); .collect();
let mut state_map = expected_state_map.clone(); let mut state_map = expected_state_map.clone();
let mut copymap = FastHashMap::default(); let mut copymap = FastHashMap::default();
copymap.insert( copymap.insert(
HgPathBuf::from_bytes(b"f1"), HgPathBuf::from_bytes(b"f1"),
); );
assert_eq!(expected_state_map, state_map); assert_eq!(expected_state_map, state_map);
} }
#[test] #[test]
fn test_parse_pack_one_entry_with_copy() { fn test_parse_pack_one_entry_with_copy() {
let mut state_map: StateMap = [( let mut state_map: StateMap = [(
HgPathBuf::from_bytes(b"f1"), HgPathBuf::from_bytes(b"f1"),
DirstateEntry { DirstateEntry::from_v1_data(
state: EntryState::Normal, EntryState::Normal,
mode: 0o644, 0o644,
size: 0, 0,
mtime: 791231220, 791231220,
}, ),
)] )]
.iter() .iter()
.cloned() .cloned()
.collect(); .collect();
let mut copymap = FastHashMap::default(); let mut copymap = FastHashMap::default();
copymap.insert( copymap.insert(
HgPathBuf::from_bytes(b"f1"), HgPathBuf::from_bytes(b"f1"),
HgPathBuf::from_bytes(b"copyname"), HgPathBuf::from_bytes(b"copyname"),
) )
} }
#[test] #[test]
fn test_parse_pack_multiple_entries_with_copy() { fn test_parse_pack_multiple_entries_with_copy() {
let mut state_map: StateMap = [ let mut state_map: StateMap = [
( (
HgPathBuf::from_bytes(b"f1"), HgPathBuf::from_bytes(b"f1"),
DirstateEntry { DirstateEntry::from_v1_data(
state: EntryState::Normal, EntryState::Normal,
mode: 0o644, 0o644,
size: 0, 0,
mtime: 791231220, 791231220,
}, ),
), ),
( (
HgPathBuf::from_bytes(b"f2"), HgPathBuf::from_bytes(b"f2"),
DirstateEntry { DirstateEntry::from_v1_data(
state: EntryState::Merged, EntryState::Merged,
mode: 0o777, 0o777,
size: 1000, 1000,
mtime: 791231220, 791231220,
}, ),
), ),
( (
HgPathBuf::from_bytes(b"f3"), HgPathBuf::from_bytes(b"f3"),
DirstateEntry { DirstateEntry::from_v1_data(
state: EntryState::Removed, EntryState::Removed,
mode: 0o644, 0o644,
size: 234553, 234553,
mtime: 791231220, 791231220,
}, ),
), ),
( (
HgPathBuf::from_bytes(b"f4\xF6"), HgPathBuf::from_bytes(b"f4\xF6"),
DirstateEntry { DirstateEntry::from_v1_data(EntryState::Added, 0o644, -1, -1),
state: EntryState::Added,
mode: 0o644,
size: -1,
mtime: -1,
},
), ),
] ]
.iter() .iter()
.cloned() .cloned()
.collect(); .collect();
let mut copymap = FastHashMap::default(); let mut copymap = FastHashMap::default();
copymap.insert( copymap.insert(
HgPathBuf::from_bytes(b"f1"), HgPathBuf::from_bytes(b"f1"),
) )
} }
#[test] #[test]
/// https://www.mercurial-scm.org/repo/hg/rev/af3f26b6bba4 /// https://www.mercurial-scm.org/repo/hg/rev/af3f26b6bba4
fn test_parse_pack_one_entry_with_copy_and_time_conflict() { fn test_parse_pack_one_entry_with_copy_and_time_conflict() {
let mut state_map: StateMap = [( let mut state_map: StateMap = [(
HgPathBuf::from_bytes(b"f1"), HgPathBuf::from_bytes(b"f1"),
DirstateEntry { DirstateEntry::from_v1_data(
state: EntryState::Normal, EntryState::Normal,
mode: 0o644, 0o644,
size: 0, 0,
mtime: 15000000, 15000000,
}, ),
)] )]
.iter() .iter()
.cloned() .cloned()
.collect(); .collect();
let mut copymap = FastHashMap::default(); let mut copymap = FastHashMap::default();
copymap.insert( copymap.insert(
HgPathBuf::from_bytes(b"f1"), HgPathBuf::from_bytes(b"f1"),
HgPathBuf::from_bytes(b"copyname"), HgPathBuf::from_bytes(b"copyname"),
.map(|(path, copy)| (path.to_owned(), copy.to_owned())) .map(|(path, copy)| (path.to_owned(), copy.to_owned()))
.collect(); .collect();
assert_eq!( assert_eq!(
( (
&parents, &parents,
[( [(
HgPathBuf::from_bytes(b"f1"), HgPathBuf::from_bytes(b"f1"),
DirstateEntry { DirstateEntry::from_v1_data(
state: EntryState::Normal, EntryState::Normal,
mode: 0o644, 0o644,
size: 0, 0,
mtime: -1 -1
} )
)] )]
.iter() .iter()
.cloned() .cloned()
.collect::<StateMap>(), .collect::<StateMap>(),
copymap, copymap,
), ),
(new_parents, new_state_map, new_copy_map) (new_parents, new_state_map, new_copy_map)
) )
} }
} }

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

/// The file corresponding to the dirstate entry was found on the filesystem. /// The file corresponding to the dirstate entry was found on the filesystem.
fn dispatch_found( fn dispatch_found(
filename: impl AsRef<HgPath>, filename: impl AsRef<HgPath>,
entry: DirstateEntry, entry: DirstateEntry,
metadata: HgMetadata, metadata: HgMetadata,
copy_map: &CopyMap, copy_map: &CopyMap,
options: StatusOptions, options: StatusOptions,
) -> Dispatch { ) -> Dispatch {
let DirstateEntry { match entry.state() {
state, EntryState::Normal => {
mode, let mode = entry.mode();
mtime, let size = entry.size();
size, let mtime = entry.mtime();
} = entry;
let HgMetadata { let HgMetadata {
st_mode, st_mode,
st_size, st_size,
st_mtime, st_mtime,
.. ..
} = metadata; } = metadata;
match state {
EntryState::Normal => {
let size_changed = mod_compare(size, st_size as i32); let size_changed = mod_compare(size, st_size as i32);
let mode_changed = let mode_changed =
(mode ^ st_mode as i32) & 0o100 != 0o000 && options.check_exec; (mode ^ st_mode as i32) & 0o100 != 0o000 && options.check_exec;
let metadata_changed = size >= 0 && (size_changed || mode_changed); let metadata_changed = size >= 0 && (size_changed || mode_changed);
let other_parent = size == SIZE_FROM_OTHER_PARENT; let other_parent = size == SIZE_FROM_OTHER_PARENT;
if metadata_changed if metadata_changed
|| other_parent || other_parent
)), )),
)) ))
}; };
} }
Err(_) => { Err(_) => {
if let Some(entry) = in_dmap { if let Some(entry) = in_dmap {
return Some(( return Some((
Cow::Borrowed(normalized), Cow::Borrowed(normalized),
dispatch_missing(entry.state), dispatch_missing(entry.state()),
)); ));
} }
} }
}; };
None None
}) })
.partition(|(_, dispatch)| match dispatch { .partition(|(_, dispatch)| match dispatch {
Dispatch::Directory { .. } => true, Dispatch::Directory { .. } => true,
} }
} }
} else if let Some(entry) = entry_option { } else if let Some(entry) = entry_option {
// Used to be a file or a folder, now something else. // Used to be a file or a folder, now something else.
if self.matcher.matches_everything() if self.matcher.matches_everything()
|| self.matcher.matches(&filename) || self.matcher.matches(&filename)
{ {
files_sender files_sender
.send((filename.to_owned(), dispatch_missing(entry.state))) .send((
filename.to_owned(),
dispatch_missing(entry.state()),
))
.unwrap(); .unwrap();
} }
} }
Ok(()) Ok(())
} }
/// A directory was found in the filesystem and needs to be traversed /// A directory was found in the filesystem and needs to be traversed
if let Some(entry) = entry_option { if let Some(entry) = entry_option {
// Used to be a file, is now a folder // Used to be a file, is now a folder
if self.matcher.matches_everything() if self.matcher.matches_everything()
|| self.matcher.matches(&directory) || self.matcher.matches(&directory)
{ {
files_sender files_sender
.send(( .send((
directory.to_owned(), directory.to_owned(),
dispatch_missing(entry.state), dispatch_missing(entry.state()),
)) ))
.unwrap(); .unwrap();
} }
} }
// Do we need to traverse it? // Do we need to traverse it?
if !self.is_ignored(&directory) || self.options.list_ignored { if !self.is_ignored(&directory) || self.options.list_ignored {
self.traverse_dir( self.traverse_dir(
files_sender, files_sender,
.symlink_metadata(); .symlink_metadata();
match meta { match meta {
Ok(m) Ok(m)
if !(m.file_type().is_file() if !(m.file_type().is_file()
|| m.file_type().is_symlink()) => || m.file_type().is_symlink()) =>
{ {
( (
Cow::Borrowed(filename), Cow::Borrowed(filename),
dispatch_missing(entry.state), dispatch_missing(entry.state()),
) )
} }
Ok(m) => ( Ok(m) => (
Cow::Borrowed(filename), Cow::Borrowed(filename),
dispatch_found( dispatch_found(
filename, filename,
*entry, *entry,
HgMetadata::from_metadata(m), HgMetadata::from_metadata(m),
&self.dmap.copy_map, &self.dmap.copy_map,
self.options, self.options,
), ),
), ),
Err(e) Err(e)
if e.kind() == ErrorKind::NotFound if e.kind() == ErrorKind::NotFound
|| e.raw_os_error() == Some(20) => || e.raw_os_error() == Some(20) =>
{ {
// Rust does not yet have an `ErrorKind` for // Rust does not yet have an `ErrorKind` for
// `NotADirectory` (errno 20) // `NotADirectory` (errno 20)
// It happens if the dirstate contains `foo/bar` // It happens if the dirstate contains `foo/bar`
// and foo is not a // and foo is not a
// directory // directory
( (
Cow::Borrowed(filename), Cow::Borrowed(filename),
dispatch_missing(entry.state), dispatch_missing(entry.state()),
) )
} }
Err(e) => { Err(e) => {
(Cow::Borrowed(filename), dispatch_os_error(&e)) (Cow::Borrowed(filename), dispatch_os_error(&e))
} }
} }
}), }),
); );
filename, filename,
*entry, *entry,
metadata, metadata,
&self.dmap.copy_map, &self.dmap.copy_map,
self.options, self.options,
) )
} }
// File doesn't exist // File doesn't exist
Err(_) => dispatch_missing(entry.state), Err(_) => dispatch_missing(entry.state()),
}, },
)) ))
} else { } else {
// It's either missing or under a symlink directory which // It's either missing or under a symlink directory which
// we, in this case, report as missing. // we, in this case, report as missing.
Some(( Some((
Cow::Owned(filename.to_owned()), Cow::Owned(filename.to_owned()),
dispatch_missing(entry.state), dispatch_missing(entry.state()),
)) ))
} }
}, },
); );
results.par_extend(new_results); results.par_extend(new_results);
} }
} }

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

} }
} }
pub(super) fn state( pub(super) fn state(
&self, &self,
) -> Result<Option<EntryState>, DirstateV2ParseError> { ) -> Result<Option<EntryState>, DirstateV2ParseError> {
match self { match self {
NodeRef::InMemory(_path, node) => { NodeRef::InMemory(_path, node) => {
Ok(node.data.as_entry().map(|entry| entry.state)) Ok(node.data.as_entry().map(|entry| entry.state()))
} }
NodeRef::OnDisk(node) => node.state(), NodeRef::OnDisk(node) => node.state(),
} }
} }
pub(super) fn cached_directory_mtime( pub(super) fn cached_directory_mtime(
&self, &self,
) -> Option<&'tree on_disk::Timestamp> { ) -> Option<&'tree on_disk::Timestamp> {
let mut map = Self::empty(on_disk); let mut map = Self::empty(on_disk);
if map.on_disk.is_empty() { if map.on_disk.is_empty() {
return Ok((map, None)); return Ok((map, None));
} }
let parents = parse_dirstate_entries( let parents = parse_dirstate_entries(
map.on_disk, map.on_disk,
|path, entry, copy_source| { |path, entry, copy_source| {
let tracked = entry.state.is_tracked(); let tracked = entry.state().is_tracked();
let node = Self::get_or_insert_node( let node = Self::get_or_insert_node(
map.on_disk, map.on_disk,
&mut map.unreachable_bytes, &mut map.unreachable_bytes,
&mut map.root, &mut map.root,
path, path,
WithBasename::to_cow_borrowed, WithBasename::to_cow_borrowed,
|ancestor| { |ancestor| {
if tracked { if tracked {
fn add_or_remove_file( fn add_or_remove_file(
&mut self, &mut self,
path: &HgPath, path: &HgPath,
old_state: EntryState, old_state: EntryState,
new_entry: DirstateEntry, new_entry: DirstateEntry,
) -> Result<(), DirstateV2ParseError> { ) -> Result<(), DirstateV2ParseError> {
let had_entry = old_state != EntryState::Unknown; let had_entry = old_state != EntryState::Unknown;
let tracked_count_increment = let tracked_count_increment =
match (old_state.is_tracked(), new_entry.state.is_tracked()) { match (old_state.is_tracked(), new_entry.state().is_tracked()) {
(false, true) => 1, (false, true) => 1,
(true, false) => -1, (true, false) => -1,
_ => 0, _ => 0,
}; };
let node = Self::get_or_insert_node( let node = Self::get_or_insert_node(
self.on_disk, self.on_disk,
&mut self.unreachable_bytes, &mut self.unreachable_bytes,
&mut self, &mut self,
filename: &HgPath, filename: &HgPath,
entry: DirstateEntry, entry: DirstateEntry,
added: bool, added: bool,
merged: bool, merged: bool,
from_p2: bool, from_p2: bool,
possibly_dirty: bool, possibly_dirty: bool,
) -> Result<(), DirstateError> { ) -> Result<(), DirstateError> {
let mut entry = entry; let state;
let size;
let mtime;
if added { if added {
assert!(!possibly_dirty); assert!(!possibly_dirty);
assert!(!from_p2); assert!(!from_p2);
entry.state = EntryState::Added; state = EntryState::Added;
entry.size = SIZE_NON_NORMAL; size = SIZE_NON_NORMAL;
entry.mtime = MTIME_UNSET; mtime = MTIME_UNSET;
} else if merged { } else if merged {
assert!(!possibly_dirty); assert!(!possibly_dirty);
assert!(!from_p2); assert!(!from_p2);
entry.state = EntryState::Merged; state = EntryState::Merged;
entry.size = SIZE_FROM_OTHER_PARENT; size = SIZE_FROM_OTHER_PARENT;
entry.mtime = MTIME_UNSET; mtime = MTIME_UNSET;
} else if from_p2 { } else if from_p2 {
assert!(!possibly_dirty); assert!(!possibly_dirty);
entry.state = EntryState::Normal; state = EntryState::Normal;
entry.size = SIZE_FROM_OTHER_PARENT; size = SIZE_FROM_OTHER_PARENT;
entry.mtime = MTIME_UNSET; mtime = MTIME_UNSET;
} else if possibly_dirty { } else if possibly_dirty {
entry.state = EntryState::Normal; state = EntryState::Normal;
entry.size = SIZE_NON_NORMAL; size = SIZE_NON_NORMAL;
entry.mtime = MTIME_UNSET; mtime = MTIME_UNSET;
} else { } else {
entry.state = EntryState::Normal; state = EntryState::Normal;
entry.size = entry.size & V1_RANGEMASK; size = entry.size() & V1_RANGEMASK;
entry.mtime = entry.mtime & V1_RANGEMASK; mtime = entry.mtime() & V1_RANGEMASK;
} }
let mode = entry.mode();
let entry = DirstateEntry::from_v1_data(state, mode, size, mtime);
let old_state = match self.get(filename)? { let old_state = match self.get(filename)? {
Some(e) => e.state, Some(e) => e.state(),
None => EntryState::Unknown, None => EntryState::Unknown,
}; };
Ok(self.add_or_remove_file(filename, old_state, entry)?) Ok(self.add_or_remove_file(filename, old_state, entry)?)
} }
fn remove_file( fn remove_file(
&mut self, &mut self,
filename: &HgPath, filename: &HgPath,
in_merge: bool, in_merge: bool,
) -> Result<(), DirstateError> { ) -> Result<(), DirstateError> {
let old_entry_opt = self.get(filename)?; let old_entry_opt = self.get(filename)?;
let old_state = match old_entry_opt { let old_state = match old_entry_opt {
Some(e) => e.state, Some(e) => e.state(),
None => EntryState::Unknown, None => EntryState::Unknown,
}; };
let mut size = 0; let mut size = 0;
if in_merge { if in_merge {
// XXX we should not be able to have 'm' state and 'FROM_P2' if not // XXX we should not be able to have 'm' state and 'FROM_P2' if not
// during a merge. So I (marmoute) am not sure we need the // during a merge. So I (marmoute) am not sure we need the
// conditionnal at all. Adding double checking this with assert // conditionnal at all. Adding double checking this with assert
// would be nice. // would be nice.
if let Some(old_entry) = old_entry_opt { if let Some(old_entry) = old_entry_opt {
// backup the previous state // backup the previous state
if old_entry.state == EntryState::Merged { if old_entry.state() == EntryState::Merged {
size = SIZE_NON_NORMAL; size = SIZE_NON_NORMAL;
} else if old_entry.state == EntryState::Normal } else if old_entry.state() == EntryState::Normal
&& old_entry.size == SIZE_FROM_OTHER_PARENT && old_entry.size() == SIZE_FROM_OTHER_PARENT
{ {
// other parent // other parent
size = SIZE_FROM_OTHER_PARENT; size = SIZE_FROM_OTHER_PARENT;
} }
} }
} }
if size == 0 { if size == 0 {
self.copy_map_remove(filename)?; self.copy_map_remove(filename)?;
} }
let entry = DirstateEntry { let entry = DirstateEntry::new_removed(size);
state: EntryState::Removed,
mode: 0,
size,
mtime: 0,
};
Ok(self.add_or_remove_file(filename, old_state, entry)?) Ok(self.add_or_remove_file(filename, old_state, entry)?)
} }
fn drop_file(&mut self, filename: &HgPath) -> Result<bool, DirstateError> { fn drop_file(&mut self, filename: &HgPath) -> Result<bool, DirstateError> {
let old_state = match self.get(filename)? { let old_state = match self.get(filename)? {
Some(e) => e.state, Some(e) => e.state(),
None => EntryState::Unknown, None => EntryState::Unknown,
}; };
struct Dropped { struct Dropped {
was_tracked: bool, was_tracked: bool,
had_entry: bool, had_entry: bool,
had_copy_source: bool, had_copy_source: bool,
} }
} }
if let Some(source) = &node.copy_source { if let Some(source) = &node.copy_source {
DirstateMap::count_dropped_path(unreachable_bytes, source) DirstateMap::count_dropped_path(unreachable_bytes, source)
} }
dropped = Dropped { dropped = Dropped {
was_tracked: node was_tracked: node
.data .data
.as_entry() .as_entry()
.map_or(false, |entry| entry.state.is_tracked()), .map_or(false, |entry| entry.state().is_tracked()),
had_entry, had_entry,
had_copy_source: node.copy_source.take().is_some(), had_copy_source: node.copy_source.take().is_some(),
}; };
} }
// After recursion, for both leaf (rest_of_path is None) nodes and // After recursion, for both leaf (rest_of_path is None) nodes and
// parent nodes, remove a node if it just became empty. // parent nodes, remove a node if it just became empty.
let remove = !node.data.has_entry() let remove = !node.data.has_entry()
&& node.copy_source.is_none() && node.copy_source.is_none()

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

b'a' => Ok(Some(EntryState::Added)), b'a' => Ok(Some(EntryState::Added)),
b'r' => Ok(Some(EntryState::Removed)), b'r' => Ok(Some(EntryState::Removed)),
b'm' => Ok(Some(EntryState::Merged)), b'm' => Ok(Some(EntryState::Merged)),
_ => Err(DirstateV2ParseError), _ => Err(DirstateV2ParseError),
} }
} }
fn entry_with_given_state(&self, state: EntryState) -> DirstateEntry { fn entry_with_given_state(&self, state: EntryState) -> DirstateEntry {
DirstateEntry { // For now, the on-disk representation of DirstateEntry in dirstate-v2
// format is equivalent to that of dirstate-v1. When that changes, add
// a new constructor.
DirstateEntry::from_v1_data(
state, state,
mode: self.data.mode.get(), self.data.mode.get(),
mtime: self.data.mtime.get(), self.data.size.get(),
size: self.data.size.get(), self.data.mtime.get(),
} )
} }
pub(super) fn entry( pub(super) fn entry(
&self, &self,
) -> Result<Option<DirstateEntry>, DirstateV2ParseError> { ) -> Result<Option<DirstateEntry>, DirstateV2ParseError> {
Ok(self Ok(self
.state()? .state()?
.map(|state| self.entry_with_given_state(state))) .map(|state| self.entry_with_given_state(state)))
start: 0.into(), start: 0.into(),
len: 0.into(), len: 0.into(),
} }
}; };
on_disk_nodes.push(match node { on_disk_nodes.push(match node {
NodeRef::InMemory(path, node) => { NodeRef::InMemory(path, node) => {
let (state, data) = match &node.data { let (state, data) = match &node.data {
dirstate_map::NodeData::Entry(entry) => ( dirstate_map::NodeData::Entry(entry) => (
entry.state.into(), entry.state().into(),
Entry { Entry {
mode: entry.mode.into(), mode: entry.mode().into(),
mtime: entry.mtime.into(), mtime: entry.mtime().into(),
size: entry.size.into(), size: entry.size().into(),
}, },
), ),
dirstate_map::NodeData::CachedDirectory { mtime } => { dirstate_map::NodeData::CachedDirectory { mtime } => {
(b'd', Entry::from_timestamp(*mtime)) (b'd', Entry::from_timestamp(*mtime))
} }
dirstate_map::NodeData::None => ( dirstate_map::NodeData::None => (
b'\0', b'\0',
Entry { Entry {

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

} }
let entry = dirstate_node let entry = dirstate_node
.entry()? .entry()?
.expect("handle_normal_file called with entry-less node"); .expect("handle_normal_file called with entry-less node");
let hg_path = &dirstate_node.full_path_borrowed(self.dmap.on_disk)?; let hg_path = &dirstate_node.full_path_borrowed(self.dmap.on_disk)?;
let mode_changed = let mode_changed =
|| self.options.check_exec && entry.mode_changed(fs_metadata); || self.options.check_exec && entry.mode_changed(fs_metadata);
let size_changed = entry.size != truncate_u64(fs_metadata.len()); let size = entry.size();
if entry.size >= 0 let size_changed = size != truncate_u64(fs_metadata.len());
&& size_changed if size >= 0 && size_changed && fs_metadata.file_type().is_symlink() {
&& fs_metadata.file_type().is_symlink()
{
// issue6456: Size returned may be longer due to encryption // issue6456: Size returned may be longer due to encryption
// on EXT-4 fscrypt. TODO maybe only do it on EXT4? // on EXT-4 fscrypt. TODO maybe only do it on EXT4?
self.outcome self.outcome
.lock() .lock()
.unwrap() .unwrap()
.unsure .unsure
.push(hg_path.detach_from_tree()) .push(hg_path.detach_from_tree())
} else if dirstate_node.has_copy_source() } else if dirstate_node.has_copy_source()
|| entry.is_from_other_parent() || entry.is_from_other_parent()
|| (entry.size >= 0 && (size_changed || mode_changed())) || (size >= 0 && (size_changed || mode_changed()))
{ {
self.outcome self.outcome
.lock() .lock()
.unwrap() .unwrap()
.modified .modified
.push(hg_path.detach_from_tree()) .push(hg_path.detach_from_tree())
} else { } else {
let mtime = mtime_seconds(fs_metadata); let mtime = mtime_seconds(fs_metadata);
if truncate_i64(mtime) != entry.mtime if truncate_i64(mtime) != entry.mtime()
|| mtime == self.options.last_normal_time || mtime == self.options.last_normal_time
{ {
self.outcome self.outcome
.lock() .lock()
.unwrap() .unwrap()
.unsure .unsure
.push(hg_path.detach_from_tree()) .push(hg_path.detach_from_tree())
} else if self.options.list_clean { } else if self.options.list_clean {

rust/hg-core/src/operations/list_tracked_files.rs

if let Some(meta) = &self.v2_metadata { if let Some(meta) = &self.v2_metadata {
for_each_tracked_path(&self.content, meta, |path| { for_each_tracked_path(&self.content, meta, |path| {
files.push(path) files.push(path)
})? })?
} else { } else {
let _parents = parse_dirstate_entries( let _parents = parse_dirstate_entries(
&self.content, &self.content,
|path, entry, _copy_source| { |path, entry, _copy_source| {
if entry.state.is_tracked() { if entry.state().is_tracked() {
files.push(path) files.push(path)
} }
Ok(()) Ok(())
}, },
)?; )?;
} }
} }
files.par_sort_unstable(); files.par_sort_unstable();

rust/hg-cpython/src/dirstate.rs

mtime: c_int, mtime: c_int,
) -> *mut RawPyObject ) -> *mut RawPyObject
); );
pub fn make_dirstate_item( pub fn make_dirstate_item(
py: Python, py: Python,
entry: &DirstateEntry, entry: &DirstateEntry,
) -> PyResult<PyObject> { ) -> PyResult<PyObject> {
let &DirstateEntry {
state,
mode,
size,
mtime,
} = entry;
// Explicitly go through u8 first, then cast to platform-specific `c_char` // Explicitly go through u8 first, then cast to platform-specific `c_char`
// because Into<u8> has a specific implementation while `as c_char` would // because Into<u8> has a specific implementation while `as c_char` would
// just do a naive enum cast. // just do a naive enum cast.
let state_code: u8 = state.into(); let state_code: u8 = entry.state().into();
make_dirstate_item_raw(py, state_code, mode, size, mtime) make_dirstate_item_raw(
py,
state_code,
entry.mode(),
entry.size(),
entry.mtime(),
)
} }
pub fn make_dirstate_item_raw( pub fn make_dirstate_item_raw(
py: Python, py: Python,
state: u8, state: u8,
mode: i32, mode: i32,
size: i32, size: i32,
mtime: i32, mtime: i32,

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

} }
} }
def set_v1(&self, path: PyObject, item: PyObject) -> PyResult<PyObject> { def set_v1(&self, path: PyObject, item: PyObject) -> PyResult<PyObject> {
let f = path.extract::<PyBytes>(py)?; let f = path.extract::<PyBytes>(py)?;
let filename = HgPath::new(f.data(py)); let filename = HgPath::new(f.data(py));
let state = item.getattr(py, "state")?.extract::<PyBytes>(py)?; let state = item.getattr(py, "state")?.extract::<PyBytes>(py)?;
let state = state.data(py)[0]; let state = state.data(py)[0];
let entry = DirstateEntry { let entry = DirstateEntry::from_v1_data(
state: state.try_into().expect("state is always valid"), state.try_into().expect("state is always valid"),
mtime: item.getattr(py, "mtime")?.extract(py)?, item.getattr(py, "mode")?.extract(py)?,
size: item.getattr(py, "size")?.extract(py)?, item.getattr(py, "size")?.extract(py)?,
mode: item.getattr(py, "mode")?.extract(py)?, item.getattr(py, "mtime")?.extract(py)?,
}; );
self.inner(py).borrow_mut().set_v1(filename, entry); self.inner(py).borrow_mut().set_v1(filename, entry);
Ok(py.None()) Ok(py.None())
} }
def addfile( def addfile(
&self, &self,
f: PyObject, f: PyObject,
mode: PyObject, mode: PyObject,
size.extract(py)? size.extract(py)?
}; };
let mtime = if mtime.is_none(py) { let mtime = if mtime.is_none(py) {
// fallback default value // fallback default value
MTIME_UNSET MTIME_UNSET
} else { } else {
mtime.extract(py)? mtime.extract(py)?
}; };
let entry = DirstateEntry { let entry = DirstateEntry::new_for_add_file(mode, size, mtime);
// XXX Arbitrary default value since the value is determined later
state: EntryState::Normal,
mode: mode,
size: size,
mtime: mtime,
};
let added = added.extract::<PyBool>(py)?.is_true(); let added = added.extract::<PyBool>(py)?.is_true();
let merged = merged.extract::<PyBool>(py)?.is_true(); let merged = merged.extract::<PyBool>(py)?.is_true();
let from_p2 = from_p2.extract::<PyBool>(py)?.is_true(); let from_p2 = from_p2.extract::<PyBool>(py)?.is_true();
let possibly_dirty = possibly_dirty.extract::<PyBool>(py)?.is_true(); let possibly_dirty = possibly_dirty.extract::<PyBool>(py)?.is_true();
self.inner(py).borrow_mut().add_file( self.inner(py).borrow_mut().add_file(
filename, filename,
entry, entry,
added, added,
)), )),
} }
} }
def filefoldmapasdict(&self) -> PyResult<PyDict> { def filefoldmapasdict(&self) -> PyResult<PyDict> {
let dict = PyDict::new(py); let dict = PyDict::new(py);
for item in self.inner(py).borrow_mut().iter() { for item in self.inner(py).borrow_mut().iter() {
let (path, entry) = item.map_err(|e| v2_error(py, e))?; let (path, entry) = item.map_err(|e| v2_error(py, e))?;
if entry.state != EntryState::Removed { if entry.state() != EntryState::Removed {
let key = normalize_case(path); let key = normalize_case(path);
let value = path; let value = path;
dict.set_item( dict.set_item(
py, py,
PyBytes::new(py, key.as_bytes()).into_object(), PyBytes::new(py, key.as_bytes()).into_object(),
PyBytes::new(py, value.as_bytes()).into_object(), PyBytes::new(py, value.as_bytes()).into_object(),
)?; )?;
} }