( )⚙ D10963 dirstate: move the handling of special case within the dirstatemap

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D10963

dirstate: move the handling of special case within the dirstatemap
ClosedPublic

Authored by marmoute on Jul 4 2021, 5:50 PM.

Details

Reviewers
SimonSapin
pulkit
Group Reviewers
hg-reviewers
Commits
rHGabed645b8e96: dirstate: move the handling of special case within the dirstatemap
Summary

The dirstatemap is as well, if not better, suited to decided how to encode the
various case. So we move the associated code in the dirstatemap addfile
method.

This means the dirstate no longer need to know about the various magic value
used in the dirstate V1 format.

The pain of the messy API start to be quite palpable in Rust, we should clean
this up once the current large refactoring is dealt with.

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

marmoute created this revision.Jul 4 2021, 5:50 PM
SimonSapin accepted this revision.Jul 5 2021, 12:42 AM
pulkit accepted this revision.Jul 6 2021, 12:35 PM
This revision is now accepted and ready to land.Jul 6 2021, 12:35 PM
baymax updated this revision to Diff 28865.Jul 6 2021, 2:09 PM

✅ refresh by Heptapod after a successful CI run (🐙 💚)

Revision Contents
Changeset List

Diff 28902

mercurial/dirstate.py

parsers = policy.importmod('parsers') parsers = policy.importmod('parsers')
rustmod = policy.importrust('dirstate') rustmod = policy.importrust('dirstate')
SUPPORTS_DIRSTATE_V2 = rustmod is not None SUPPORTS_DIRSTATE_V2 = rustmod is not None
propertycache = util.propertycache propertycache = util.propertycache
filecache = scmutil.filecache filecache = scmutil.filecache
_rangemask = 0x7FFFFFFF _rangemask = dirstatemap.rangemask
dirstatetuple = parsers.dirstatetuple dirstatetuple = parsers.dirstatetuple
# a special value used internally for `size` if the file come from the other parent # a special value used internally for `size` if the file come from the other parent
FROM_P2 = dirstatemap.FROM_P2 FROM_P2 = dirstatemap.FROM_P2
# a special value used internally for `size` if the file is modified/merged/added # a special value used internally for `size` if the file is modified/merged/added
NONNORMAL = dirstatemap.NONNORMAL NONNORMAL = dirstatemap.NONNORMAL
# a special value used internally for `time` if the time is ambigeous # a special value used internally for `time` if the time is ambigeous
AMBIGUOUS_TIME = dirstatemap.AMBIGUOUS_TIME AMBIGUOUS_TIME = dirstatemap.AMBIGUOUS_TIME
def copies(self): def copies(self):
return self._map.copymap return self._map.copymap
def _addpath( def _addpath(
self, self,
f, f,
state, state,
mode, mode,
size=NONNORMAL, size=None,
mtime=AMBIGUOUS_TIME, mtime=None,
from_p2=False, from_p2=False,
possibly_dirty=False, possibly_dirty=False,
): ):
oldstate = self[f] oldstate = self[f]
if state == b'a' or oldstate == b'r': if state == b'a' or oldstate == b'r':
scmutil.checkfilename(f) scmutil.checkfilename(f)
if self._map.hastrackeddir(f): if self._map.hastrackeddir(f):
msg = _(b'directory %r already in dirstate') msg = _(b'directory %r already in dirstate')
msg %= pycompat.bytestr(f) msg %= pycompat.bytestr(f)
raise error.Abort(msg) raise error.Abort(msg)
# shadows # shadows
for d in pathutil.finddirs(f): for d in pathutil.finddirs(f):
if self._map.hastrackeddir(d): if self._map.hastrackeddir(d):
break break
entry = self._map.get(d) entry = self._map.get(d)
if entry is not None and not entry.removed: if entry is not None and not entry.removed:
msg = _(b'file %r in dirstate clashes with %r') msg = _(b'file %r in dirstate clashes with %r')
msg %= (pycompat.bytestr(d), pycompat.bytestr(f)) msg %= (pycompat.bytestr(d), pycompat.bytestr(f))
raise error.Abort(msg) raise error.Abort(msg)
if state == b'a':
assert not possibly_dirty
assert not from_p2
size = NONNORMAL
mtime = AMBIGUOUS_TIME
elif from_p2:
assert not possibly_dirty
size = FROM_P2
mtime = AMBIGUOUS_TIME
elif possibly_dirty:
mtime = AMBIGUOUS_TIME
else:
assert size != FROM_P2
assert size != NONNORMAL
size = size & _rangemask
mtime = mtime & _rangemask
self._dirty = True self._dirty = True
self._updatedfiles.add(f) self._updatedfiles.add(f)
self._map.addfile(f, oldstate, state, mode, size, mtime) self._map.addfile(
f,
oldstate,
state=state,
mode=mode,
size=size,
mtime=mtime,
from_p2=from_p2,
possibly_dirty=possibly_dirty,
)
def normal(self, f, parentfiledata=None): def normal(self, f, parentfiledata=None):
"""Mark a file normal and clean. """Mark a file normal and clean.
parentfiledata: (mode, size, mtime) of the clean file parentfiledata: (mode, size, mtime) of the clean file
parentfiledata should be computed from memory (for mode, parentfiledata should be computed from memory (for mode,
size), as or close as possible from the point where we size), as or close as possible from the point where we

mercurial/dirstatemap.py

FROM_P2 = -2 FROM_P2 = -2
# a special value used internally for `size` if the file is modified/merged/added # a special value used internally for `size` if the file is modified/merged/added
NONNORMAL = -1 NONNORMAL = -1
# a special value used internally for `time` if the time is ambigeous # a special value used internally for `time` if the time is ambigeous
AMBIGUOUS_TIME = -1 AMBIGUOUS_TIME = -1
rangemask = 0x7FFFFFFF
class dirstatemap(object): class dirstatemap(object):
"""Map encapsulating the dirstate's contents. """Map encapsulating the dirstate's contents.
The dirstate contains the following state: The dirstate contains the following state:
- `identity` is the identity of the dirstate file, which can be used to - `identity` is the identity of the dirstate file, which can be used to
detect when changes have occurred to the dirstate file. detect when changes have occurred to the dirstate file.
def keys(self): def keys(self):
return self._map.keys() return self._map.keys()
def preload(self): def preload(self):
"""Loads the underlying data, if it's not already loaded""" """Loads the underlying data, if it's not already loaded"""
self._map self._map
def addfile(self, f, oldstate, state, mode, size, mtime): def addfile(
self,
f,
oldstate,
state,
mode,
size=None,
mtime=None,
from_p2=False,
possibly_dirty=False,
):
"""Add a tracked file to the dirstate.""" """Add a tracked file to the dirstate."""
if state == b'a':
assert not possibly_dirty
assert not from_p2
size = NONNORMAL
mtime = AMBIGUOUS_TIME
elif from_p2:
assert not possibly_dirty
size = FROM_P2
mtime = AMBIGUOUS_TIME
elif possibly_dirty:
size = NONNORMAL
mtime = AMBIGUOUS_TIME
else:
assert size != FROM_P2
assert size != NONNORMAL
size = size & rangemask
mtime = mtime & rangemask
assert size is not None
assert mtime is not None
if oldstate in b"?r" and "_dirs" in self.__dict__: if oldstate in b"?r" and "_dirs" in self.__dict__:
self._dirs.addpath(f) self._dirs.addpath(f)
if oldstate == b"?" and "_alldirs" in self.__dict__: if oldstate == b"?" and "_alldirs" in self.__dict__:
self._alldirs.addpath(f) self._alldirs.addpath(f)
self._map[f] = dirstatetuple(state, mode, size, mtime) self._map[f] = dirstatetuple(state, mode, size, mtime)
if state != b'n' or mtime == AMBIGUOUS_TIME: if state != b'n' or mtime == AMBIGUOUS_TIME:
self.nonnormalset.add(f) self.nonnormalset.add(f)
if size == FROM_P2: if size == FROM_P2:
self._pendingmode = None self._pendingmode = None
self._use_dirstate_tree = self._ui.configbool( self._use_dirstate_tree = self._ui.configbool(
b"experimental", b"experimental",
b"dirstate-tree.in-memory", b"dirstate-tree.in-memory",
False, False,
) )
def addfile(self, *args, **kwargs): def addfile(
return self._rustmap.addfile(*args, **kwargs) self,
f,
oldstate,
state,
mode,
size=None,
mtime=None,
from_p2=False,
possibly_dirty=False,
):
return self._rustmap.addfile(
f,
oldstate,
state,
mode,
size,
mtime,
from_p2,
possibly_dirty,
)
def removefile(self, *args, **kwargs): def removefile(self, *args, **kwargs):
return self._rustmap.removefile(*args, **kwargs) return self._rustmap.removefile(*args, **kwargs)
def dropfile(self, *args, **kwargs): def dropfile(self, *args, **kwargs):
return self._rustmap.dropfile(*args, **kwargs) return self._rustmap.dropfile(*args, **kwargs)
def clearambiguoustimes(self, *args, **kwargs): def clearambiguoustimes(self, *args, **kwargs):

rust/hg-core/src/dirstate.rs

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 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.

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

// dirstate_map.rs // dirstate_map.rs
// //
// Copyright 2019 Raphaël Gomès <rgomes@octobus.net> // Copyright 2019 Raphaël Gomès <rgomes@octobus.net>
// //
// This software may be used and distributed according to the terms of the // This software may be used and distributed according to the terms of the
// GNU General Public License version 2 or any later version. // GNU General Public License version 2 or any later version.
use crate::dirstate::parsers::Timestamp; use crate::dirstate::parsers::Timestamp;
use crate::{ use crate::{
dirstate::EntryState, dirstate::EntryState,
dirstate::MTIME_UNSET,
dirstate::SIZE_FROM_OTHER_PARENT, dirstate::SIZE_FROM_OTHER_PARENT,
dirstate::SIZE_NON_NORMAL, dirstate::SIZE_NON_NORMAL,
dirstate::V1_RANGEMASK,
pack_dirstate, parse_dirstate, pack_dirstate, parse_dirstate,
utils::hg_path::{HgPath, HgPathBuf}, utils::hg_path::{HgPath, HgPathBuf},
CopyMap, DirsMultiset, DirstateEntry, DirstateError, DirstateParents, CopyMap, DirsMultiset, DirstateEntry, DirstateError, DirstateParents,
StateMap, StateMap,
}; };
use micro_timer::timed; use micro_timer::timed;
use std::collections::HashSet; use std::collections::HashSet;
use std::iter::FromIterator; use std::iter::FromIterator;
} }
/// Add a tracked file to the dirstate /// Add a tracked file to the dirstate
pub fn add_file( pub fn add_file(
&mut self, &mut self,
filename: &HgPath, filename: &HgPath,
old_state: EntryState, old_state: EntryState,
entry: DirstateEntry, entry: DirstateEntry,
// XXX once the dust settle this should probably become an enum
from_p2: bool,
possibly_dirty: bool,
) -> Result<(), DirstateError> { ) -> Result<(), DirstateError> {
let mut entry = entry;
if entry.state == EntryState::Added {
assert!(!possibly_dirty);
assert!(!from_p2);
entry.size = SIZE_NON_NORMAL;
entry.mtime = MTIME_UNSET;
} else if from_p2 {
assert!(!possibly_dirty);
entry.size = SIZE_FROM_OTHER_PARENT;
entry.mtime = MTIME_UNSET;
} else if possibly_dirty {
entry.size = SIZE_NON_NORMAL;
entry.mtime = MTIME_UNSET;
} else {
entry.size = entry.size & V1_RANGEMASK;
entry.mtime = entry.mtime & V1_RANGEMASK;
}
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)?;
} }
} }
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 {
HgPath::new(b"meh"), HgPath::new(b"meh"),
EntryState::Normal, EntryState::Normal,
DirstateEntry { DirstateEntry {
state: EntryState::Normal, state: EntryState::Normal,
mode: 1337, mode: 1337,
mtime: 1337, mtime: 1337,
size: 1337, size: 1337,
}, },
false,
false,
) )
.unwrap(); .unwrap();
assert_eq!(1, map.len()); assert_eq!(1, map.len());
assert_eq!(0, map.get_non_normal_other_parent_entries().0.len()); assert_eq!(0, map.get_non_normal_other_parent_entries().0.len());
assert_eq!(0, map.get_non_normal_other_parent_entries().1.len()); assert_eq!(0, map.get_non_normal_other_parent_entries().1.len());
} }

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

use bytes_cast::BytesCast; use bytes_cast::BytesCast;
use micro_timer::timed; use micro_timer::timed;
use std::borrow::Cow; use std::borrow::Cow;
use std::convert::TryInto; use std::convert::TryInto;
use std::path::PathBuf; use std::path::PathBuf;
use super::on_disk; use super::on_disk;
use super::on_disk::DirstateV2ParseError; use super::on_disk::DirstateV2ParseError;
use super::path_with_basename::WithBasename; use super::path_with_basename::WithBasename;
use crate::dirstate::parsers::pack_entry; use crate::dirstate::parsers::pack_entry;
use crate::dirstate::parsers::packed_entry_size; use crate::dirstate::parsers::packed_entry_size;
use crate::dirstate::parsers::parse_dirstate_entries; use crate::dirstate::parsers::parse_dirstate_entries;
use crate::dirstate::parsers::Timestamp; use crate::dirstate::parsers::Timestamp;
use crate::dirstate::MTIME_UNSET;
use crate::dirstate::SIZE_FROM_OTHER_PARENT; use crate::dirstate::SIZE_FROM_OTHER_PARENT;
use crate::dirstate::SIZE_NON_NORMAL; use crate::dirstate::SIZE_NON_NORMAL;
use crate::dirstate::V1_RANGEMASK;
use crate::matchers::Matcher; use crate::matchers::Matcher;
use crate::utils::hg_path::{HgPath, HgPathBuf}; use crate::utils::hg_path::{HgPath, HgPathBuf};
use crate::CopyMapIter; use crate::CopyMapIter;
use crate::DirstateEntry; use crate::DirstateEntry;
use crate::DirstateError; use crate::DirstateError;
use crate::DirstateParents; use crate::DirstateParents;
use crate::DirstateStatus; use crate::DirstateStatus;
use crate::EntryState; use crate::EntryState;
self.nodes_with_copy_source_count = 0; self.nodes_with_copy_source_count = 0;
} }
fn add_file( fn add_file(
&mut self, &mut self,
filename: &HgPath, filename: &HgPath,
old_state: EntryState, old_state: EntryState,
entry: DirstateEntry, entry: DirstateEntry,
from_p2: bool,
possibly_dirty: bool,
) -> Result<(), DirstateError> { ) -> Result<(), DirstateError> {
let mut entry = entry;
if entry.state == EntryState::Added {
assert!(!possibly_dirty);
assert!(!from_p2);
entry.size = SIZE_NON_NORMAL;
entry.mtime = MTIME_UNSET;
} else if from_p2 {
assert!(!possibly_dirty);
entry.size = SIZE_FROM_OTHER_PARENT;
entry.mtime = MTIME_UNSET;
} else if possibly_dirty {
entry.size = SIZE_NON_NORMAL;
entry.mtime = MTIME_UNSET;
} else {
entry.size = entry.size & V1_RANGEMASK;
entry.mtime = entry.mtime & V1_RANGEMASK;
}
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> {

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

/// before this call, or `EntryState::Unknown` if there was no such entry. /// before this call, or `EntryState::Unknown` if there was no such entry.
/// ///
/// `entry.state` should never be `EntryState::Unknown`. /// `entry.state` should never be `EntryState::Unknown`.
fn add_file( fn add_file(
&mut self, &mut self,
filename: &HgPath, filename: &HgPath,
old_state: EntryState, old_state: EntryState,
entry: DirstateEntry, entry: DirstateEntry,
from_p2: bool,
possibly_dirty: bool,
) -> Result<(), DirstateError>; ) -> Result<(), DirstateError>;
/// Mark a file as "removed" (as in `hg rm`). /// Mark a file as "removed" (as in `hg rm`).
/// ///
/// `old_state` is the state in the entry that `get` would have returned /// `old_state` is the state in the entry that `get` would have returned
/// before this call, or `EntryState::Unknown` if there was no such entry. /// before this call, or `EntryState::Unknown` if there was no such entry.
/// ///
/// `size` is not actually a size but the 0 or -1 or -2 value that would be /// `size` is not actually a size but the 0 or -1 or -2 value that would be
self.clear() self.clear()
} }
fn add_file( fn add_file(
&mut self, &mut self,
filename: &HgPath, filename: &HgPath,
old_state: EntryState, old_state: EntryState,
entry: DirstateEntry, entry: DirstateEntry,
from_p2: bool,
possibly_dirty: bool,
) -> Result<(), DirstateError> { ) -> Result<(), DirstateError> {
self.add_file(filename, old_state, entry) self.add_file(filename, old_state, entry, from_p2, possibly_dirty)
} }
fn remove_file( fn remove_file(
&mut self, &mut self,
filename: &HgPath, filename: &HgPath,
in_merge: bool, in_merge: bool,
) -> Result<(), DirstateError> { ) -> Result<(), DirstateError> {
self.remove_file(filename, in_merge) self.remove_file(filename, in_merge)

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

dirstate::non_normal_entries::{ dirstate::non_normal_entries::{
NonNormalEntries, NonNormalEntriesIterator, NonNormalEntries, NonNormalEntriesIterator,
}, },
dirstate::owning::OwningDirstateMap, dirstate::owning::OwningDirstateMap,
parsers::dirstate_parents_to_pytuple, parsers::dirstate_parents_to_pytuple,
}; };
use hg::{ use hg::{
dirstate::parsers::Timestamp, dirstate::parsers::Timestamp,
dirstate::MTIME_UNSET,
dirstate::SIZE_NON_NORMAL,
dirstate_tree::dispatch::DirstateMapMethods, dirstate_tree::dispatch::DirstateMapMethods,
dirstate_tree::on_disk::DirstateV2ParseError, dirstate_tree::on_disk::DirstateV2ParseError,
errors::HgError, errors::HgError,
revlog::Node, revlog::Node,
utils::files::normalize_case, utils::files::normalize_case,
utils::hg_path::{HgPath, HgPathBuf}, utils::hg_path::{HgPath, HgPathBuf},
DirstateEntry, DirstateError, DirstateMap as RustDirstateMap, DirstateEntry, DirstateError, DirstateMap as RustDirstateMap,
DirstateParents, EntryState, StateMapIter, DirstateParents, EntryState, StateMapIter,
def addfile( def addfile(
&self, &self,
f: PyObject, f: PyObject,
oldstate: PyObject, oldstate: PyObject,
state: PyObject, state: PyObject,
mode: PyObject, mode: PyObject,
size: PyObject, size: PyObject,
mtime: PyObject mtime: PyObject,
from_p2: PyObject,
possibly_dirty: PyObject,
) -> PyResult<PyObject> { ) -> PyResult<PyObject> {
let f = f.extract::<PyBytes>(py)?; let f = f.extract::<PyBytes>(py)?;
let filename = HgPath::new(f.data(py)); let filename = HgPath::new(f.data(py));
let oldstate = oldstate.extract::<PyBytes>(py)?.data(py)[0] let oldstate = oldstate.extract::<PyBytes>(py)?.data(py)[0]
.try_into() .try_into()
.map_err(|e: HgError| { .map_err(|e: HgError| {
PyErr::new::<exc::ValueError, _>(py, e.to_string()) PyErr::new::<exc::ValueError, _>(py, e.to_string())
})?; })?;
let state = state.extract::<PyBytes>(py)?.data(py)[0] let state = state.extract::<PyBytes>(py)?.data(py)[0]
.try_into() .try_into()
.map_err(|e: HgError| { .map_err(|e: HgError| {
PyErr::new::<exc::ValueError, _>(py, e.to_string()) PyErr::new::<exc::ValueError, _>(py, e.to_string())
})?; })?;
let mode = mode.extract(py)?; let mode = mode.extract(py)?;
let size = size.extract(py)?; let size = if size.is_none(py) {
let mtime = mtime.extract(py)?; // fallback default value
SIZE_NON_NORMAL
} else {
size.extract(py)?
};
let mtime = if mtime.is_none(py) {
// fallback default value
MTIME_UNSET
} else {
mtime.extract(py)?
};
let entry = DirstateEntry { let entry = DirstateEntry {
state: state, state: state,
mode: mode, mode: mode,
size: size, size: size,
mtime: mtime, mtime: mtime,
}; };
let from_p2 = from_p2.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,
oldstate, oldstate,
entry, entry,
from_p2,
possibly_dirty
).and(Ok(py.None())).or_else(|e: DirstateError| { ).and(Ok(py.None())).or_else(|e: DirstateError| {
Err(PyErr::new::<exc::ValueError, _>(py, e.to_string())) Err(PyErr::new::<exc::ValueError, _>(py, e.to_string()))
}) })
} }
def removefile( def removefile(
&self, &self,
f: PyObject, f: PyObject,

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

self.get_mut().clear() self.get_mut().clear()
} }
fn add_file( fn add_file(
&mut self, &mut self,
filename: &HgPath, filename: &HgPath,
old_state: EntryState, old_state: EntryState,
entry: DirstateEntry, entry: DirstateEntry,
from_p2: bool,
possibly_dirty: bool,
) -> Result<(), DirstateError> { ) -> Result<(), DirstateError> {
self.get_mut().add_file(filename, old_state, entry) self.get_mut().add_file(
filename,
old_state,
entry,
from_p2,
possibly_dirty,
)
} }
fn remove_file( fn remove_file(
&mut self, &mut self,
filename: &HgPath, filename: &HgPath,
in_merge: bool, in_merge: bool,
) -> Result<(), DirstateError> { ) -> Result<(), DirstateError> {
self.get_mut().remove_file(filename, in_merge) self.get_mut().remove_file(filename, in_merge)