This is an archive of the discontinued Mercurial Phabricator instance.

Differential D12498

rust-dirstate: introduce intermediate struct for dirstate-v2 data
ClosedPublic

Authored by Alphare on Apr 12 2022, 12:02 PM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Commits
rHG38e5bb1425dd: rust-dirstate: introduce intermediate struct for dirstate-v2 data
Summary

This is passed often as a long tuple that is not easy to know the form of, so
we refactor everything in this struct.

This also renames wdir_tracked to follow the Python wc_tracked, even though
the on-disk format uses WDIR_TRACKED.
I think a single naming scheme is better, but we can't easily break the Python
impl now because of extensions, so this is low-effort enough and facilitates
grepping.

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

Alphare created this revision.Apr 12 2022, 12:02 PM
Alphare added a commit: rHG38e5bb1425dd: rust-dirstate: introduce intermediate struct for dirstate-v2 data.Apr 19 2022, 5:54 PM
This revision was not accepted when it landed; it landed in state Needs Review.
Closed by commit rHG38e5bb1425dd: rust-dirstate: introduce intermediate struct for dirstate-v2 data (authored by Alphare). · Explain Why
This revision was automatically updated to reflect the committed changes.

Revision Contents
Changeset List

Diff 33252

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

/// 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;
#[derive(Debug, Default, Copy, Clone)]
pub struct DirstateV2Data {
pub wc_tracked: bool,
pub p1_tracked: bool,
pub p2_info: bool,
pub mode_size: Option<(u32, u32)>,
pub mtime: Option<TruncatedTimestamp>,
pub fallback_exec: Option<bool>,
pub fallback_symlink: Option<bool>,
}
impl DirstateEntry { impl DirstateEntry {
pub fn from_v2_data( pub fn from_v2_data(v2_data: DirstateV2Data) -> Self {
wdir_tracked: bool, let DirstateV2Data {
p1_tracked: bool, wc_tracked,
p2_info: bool, p1_tracked,
mode_size: Option<(u32, u32)>, p2_info,
mtime: Option<TruncatedTimestamp>, mode_size,
fallback_exec: Option<bool>, mtime,
fallback_symlink: Option<bool>, fallback_exec,
) -> Self { fallback_symlink,
} = v2_data;
if let Some((mode, size)) = mode_size { if let Some((mode, size)) = mode_size {
// TODO: return an error for out of range values? // TODO: return an error for out of range values?
assert!(mode & !RANGE_MASK_31BIT == 0); assert!(mode & !RANGE_MASK_31BIT == 0);
assert!(size & !RANGE_MASK_31BIT == 0); assert!(size & !RANGE_MASK_31BIT == 0);
} }
let mut flags = Flags::empty(); let mut flags = Flags::empty();
flags.set(Flags::WDIR_TRACKED, wdir_tracked); flags.set(Flags::WDIR_TRACKED, wc_tracked);
flags.set(Flags::P1_TRACKED, p1_tracked); flags.set(Flags::P1_TRACKED, p1_tracked);
flags.set(Flags::P2_INFO, p2_info); flags.set(Flags::P2_INFO, p2_info);
if let Some(exec) = fallback_exec { if let Some(exec) = fallback_exec {
flags.insert(Flags::HAS_FALLBACK_EXEC); flags.insert(Flags::HAS_FALLBACK_EXEC);
if exec { if exec {
flags.insert(Flags::FALLBACK_EXEC); flags.insert(Flags::FALLBACK_EXEC);
} }
} }
/// ///
/// `size` is expected to be zero, `SIZE_NON_NORMAL`, or /// `size` is expected to be zero, `SIZE_NON_NORMAL`, or
/// `SIZE_FROM_OTHER_PARENT` /// `SIZE_FROM_OTHER_PARENT`
pub fn new_removed(size: i32) -> Self { pub fn new_removed(size: i32) -> Self {
Self::from_v1_data(EntryState::Removed, 0, size, 0) Self::from_v1_data(EntryState::Removed, 0, size, 0)
} }
pub fn new_tracked() -> Self { pub fn new_tracked() -> Self {
Self::from_v2_data(true, false, false, None, None, None, None) let data = DirstateV2Data {
wc_tracked: true,
..Default::default()
};
Self::from_v2_data(data)
} }
pub fn tracked(&self) -> bool { pub fn tracked(&self) -> bool {
self.flags.contains(Flags::WDIR_TRACKED) self.flags.contains(Flags::WDIR_TRACKED)
} }
pub fn p1_tracked(&self) -> bool { pub fn p1_tracked(&self) -> bool {
self.flags.contains(Flags::P1_TRACKED) self.flags.contains(Flags::P1_TRACKED)
} }
pub fn any_tracked(&self) -> bool { pub fn any_tracked(&self) -> bool {
self.flags.intersects( self.flags.intersects(
Flags::WDIR_TRACKED | Flags::P1_TRACKED | Flags::P2_INFO, 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) -> DirstateV2Data {
pub(crate) fn v2_data(
&self,
) -> (
bool,
bool,
bool,
Option<(u32, u32)>,
Option<TruncatedTimestamp>,
Option<bool>,
Option<bool>,
) {
if !self.any_tracked() { if !self.any_tracked() {
// TODO: return an Option instead? // TODO: return an Option instead?
panic!("Accessing v2_data of an untracked DirstateEntry") panic!("Accessing v2_data of an untracked DirstateEntry")
} }
let wdir_tracked = self.flags.contains(Flags::WDIR_TRACKED); let wc_tracked = self.flags.contains(Flags::WDIR_TRACKED);
let p1_tracked = self.flags.contains(Flags::P1_TRACKED); let p1_tracked = self.flags.contains(Flags::P1_TRACKED);
let p2_info = self.flags.contains(Flags::P2_INFO); let p2_info = self.flags.contains(Flags::P2_INFO);
let mode_size = self.mode_size; let mode_size = self.mode_size;
let mtime = self.mtime; let mtime = self.mtime;
( DirstateV2Data {
wdir_tracked, wc_tracked,
p1_tracked, p1_tracked,
p2_info, p2_info,
mode_size, mode_size,
mtime, mtime,
self.get_fallback_exec(), fallback_exec: self.get_fallback_exec(),
self.get_fallback_symlink(), fallback_symlink: self.get_fallback_symlink(),
) }
} }
fn v1_state(&self) -> EntryState { fn v1_state(&self) -> EntryState {
if !self.any_tracked() { if !self.any_tracked() {
// TODO: return an Option instead? // TODO: return an Option instead?
panic!("Accessing v1_state of an untracked DirstateEntry") panic!("Accessing v1_state of an untracked DirstateEntry")
} }
if self.removed() { if self.removed() {

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

//! The "version 2" disk representation of the dirstate //! The "version 2" disk representation of the dirstate
//! //!
//! See `mercurial/helptext/internals/dirstate-v2.txt` //! See `mercurial/helptext/internals/dirstate-v2.txt`
use crate::dirstate::TruncatedTimestamp; use crate::dirstate::{DirstateV2Data, TruncatedTimestamp};
use crate::dirstate_tree::dirstate_map::{self, DirstateMap, NodeRef}; use crate::dirstate_tree::dirstate_map::{self, DirstateMap, NodeRef};
use crate::dirstate_tree::path_with_basename::WithBasename; use crate::dirstate_tree::path_with_basename::WithBasename;
use crate::errors::HgError; use crate::errors::HgError;
use crate::utils::hg_path::HgPath; use crate::utils::hg_path::HgPath;
use crate::DirstateEntry; use crate::DirstateEntry;
use crate::DirstateError; use crate::DirstateError;
use crate::DirstateParents; use crate::DirstateParents;
use bitflags::bitflags; use bitflags::bitflags;
if self.flags().contains(Flags::MTIME_SECOND_AMBIGUOUS) { if self.flags().contains(Flags::MTIME_SECOND_AMBIGUOUS) {
m.second_ambiguous = true; m.second_ambiguous = true;
} }
Ok(m) Ok(m)
} }
fn assume_entry(&self) -> Result<DirstateEntry, DirstateV2ParseError> { fn assume_entry(&self) -> Result<DirstateEntry, DirstateV2ParseError> {
// TODO: convert through raw bits instead? // TODO: convert through raw bits instead?
let wdir_tracked = self.flags().contains(Flags::WDIR_TRACKED); let wc_tracked = self.flags().contains(Flags::WDIR_TRACKED);
let p1_tracked = self.flags().contains(Flags::P1_TRACKED); let p1_tracked = self.flags().contains(Flags::P1_TRACKED);
let p2_info = self.flags().contains(Flags::P2_INFO); let p2_info = self.flags().contains(Flags::P2_INFO);
let mode_size = if self.flags().contains(Flags::HAS_MODE_AND_SIZE) let mode_size = if self.flags().contains(Flags::HAS_MODE_AND_SIZE)
&& !self.flags().contains(Flags::EXPECTED_STATE_IS_MODIFIED) && !self.flags().contains(Flags::EXPECTED_STATE_IS_MODIFIED)
{ {
Some((self.synthesize_unix_mode(), self.size.into())) Some((self.synthesize_unix_mode(), self.size.into()))
} else { } else {
None None
None None
}; };
let fallback_symlink = let fallback_symlink =
if self.flags().contains(Flags::HAS_FALLBACK_SYMLINK) { if self.flags().contains(Flags::HAS_FALLBACK_SYMLINK) {
Some(self.flags().contains(Flags::FALLBACK_SYMLINK)) Some(self.flags().contains(Flags::FALLBACK_SYMLINK))
} else { } else {
None None
}; };
Ok(DirstateEntry::from_v2_data( Ok(DirstateEntry::from_v2_data(DirstateV2Data {
wdir_tracked, wc_tracked,
p1_tracked, p1_tracked,
p2_info, p2_info,
mode_size, mode_size,
mtime, mtime,
fallback_exec, fallback_exec,
fallback_symlink, fallback_symlink,
)) }))
} }
pub(super) fn entry( pub(super) fn entry(
&self, &self,
) -> Result<Option<DirstateEntry>, DirstateV2ParseError> { ) -> Result<Option<DirstateEntry>, DirstateV2ParseError> {
if self.has_entry() { if self.has_entry() {
Ok(Some(self.assume_entry()?)) Ok(Some(self.assume_entry()?))
} else { } else {
.get(), .get(),
tracked_descendants_count: self.tracked_descendants_count.get(), tracked_descendants_count: self.tracked_descendants_count.get(),
}) })
} }
fn from_dirstate_entry( fn from_dirstate_entry(
entry: &DirstateEntry, entry: &DirstateEntry,
) -> (Flags, U32Be, PackedTruncatedTimestamp) { ) -> (Flags, U32Be, PackedTruncatedTimestamp) {
let ( let DirstateV2Data {
wdir_tracked, wc_tracked,
p1_tracked, p1_tracked,
p2_info, p2_info,
mode_size_opt, mode_size: mode_size_opt,
mtime_opt, mtime: mtime_opt,
fallback_exec, fallback_exec,
fallback_symlink, fallback_symlink,
) = entry.v2_data(); } = entry.v2_data();
// TODO: convert throug raw flag bits instead? // TODO: convert through raw flag bits instead?
let mut flags = Flags::empty(); let mut flags = Flags::empty();
flags.set(Flags::WDIR_TRACKED, wdir_tracked); flags.set(Flags::WDIR_TRACKED, wc_tracked);
flags.set(Flags::P1_TRACKED, p1_tracked); flags.set(Flags::P1_TRACKED, p1_tracked);
flags.set(Flags::P2_INFO, p2_info); flags.set(Flags::P2_INFO, p2_info);
let size = if let Some((m, s)) = mode_size_opt { let size = if let Some((m, s)) = mode_size_opt {
let exec_perm = m & (libc::S_IXUSR as u32) != 0; let exec_perm = m & (libc::S_IXUSR as u32) != 0;
let is_symlink = m & (libc::S_IFMT as u32) == libc::S_IFLNK as u32; let is_symlink = m & (libc::S_IFMT as u32) == libc::S_IFLNK as u32;
flags.set(Flags::MODE_EXEC_PERM, exec_perm); flags.set(Flags::MODE_EXEC_PERM, exec_perm);
flags.set(Flags::MODE_IS_SYMLINK, is_symlink); flags.set(Flags::MODE_IS_SYMLINK, is_symlink);
flags.insert(Flags::HAS_MODE_AND_SIZE); flags.insert(Flags::HAS_MODE_AND_SIZE);

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

use cpython::exc; use cpython::exc;
use cpython::ObjectProtocol; use cpython::ObjectProtocol;
use cpython::PyBytes; use cpython::PyBytes;
use cpython::PyErr; use cpython::PyErr;
use cpython::PyNone; use cpython::PyNone;
use cpython::PyObject; use cpython::PyObject;
use cpython::PyResult; use cpython::PyResult;
use cpython::Python; use cpython::Python;
use cpython::PythonObject; use cpython::PythonObject;
use hg::dirstate::DirstateEntry; use hg::dirstate::DirstateEntry;
use hg::dirstate::DirstateV2Data;
use hg::dirstate::TruncatedTimestamp; use hg::dirstate::TruncatedTimestamp;
use std::cell::Cell; use std::cell::Cell;
py_class!(pub class DirstateItem |py| { py_class!(pub class DirstateItem |py| {
data entry: Cell<DirstateEntry>; data entry: Cell<DirstateEntry>;
def __new__( def __new__(
_cls, _cls,
mode_size_opt = Some((mode, size)) mode_size_opt = Some((mode, size))
} }
if has_meaningful_mtime { if has_meaningful_mtime {
if let Some(m) = mtime { if let Some(m) = mtime {
mtime_opt = Some(timestamp(py, m)?); mtime_opt = Some(timestamp(py, m)?);
} }
} }
} }
let entry = DirstateEntry::from_v2_data( let entry = DirstateEntry::from_v2_data(DirstateV2Data {
wc_tracked, wc_tracked: wc_tracked,
p1_tracked, p1_tracked,
p2_info, p2_info,
mode_size_opt, mode_size: mode_size_opt,
mtime_opt, mtime: mtime_opt,
fallback_exec, fallback_exec,
fallback_symlink, fallback_symlink,
); });
DirstateItem::create_instance(py, Cell::new(entry)) DirstateItem::create_instance(py, Cell::new(entry))
} }
@property @property
def state(&self) -> PyResult<PyBytes> { def state(&self) -> PyResult<PyBytes> {
let state_byte: u8 = self.entry(py).get().state().into(); let state_byte: u8 = self.entry(py).get().state().into();
Ok(PyBytes::new(py, &[state_byte])) Ok(PyBytes::new(py, &[state_byte]))
} }