( )⚙ D10966 dirstate: no longer pass the `oldstate` value to the dirstatemap

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D10966

dirstate: no longer pass the `oldstate` value to the dirstatemap
ClosedPublic

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

Details

Reviewers
SimonSapin
pulkit
Group Reviewers
hg-reviewers
Commits
rHG69a463a4f193: dirstate: no longer pass the `oldstate` value to the dirstatemap
Summary

The dirstatemap already have this information.

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:51 PM
SimonSapin accepted this revision.Jul 5 2021, 12:45 AM
pulkit accepted this revision.Jul 6 2021, 12:37 PM
This revision is now accepted and ready to land.Jul 6 2021, 12:37 PM
baymax updated this revision to Diff 28868.Jul 6 2021, 2:09 PM

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

Revision Contents
Changeset List

Diff 28905

mercurial/dirstate.py

f, f,
state, state,
mode, mode,
size=None, size=None,
mtime=None, mtime=None,
from_p2=False, from_p2=False,
possibly_dirty=False, possibly_dirty=False,
): ):
oldstate = self[f]
entry = self._map.get(f) entry = self._map.get(f)
if state == b'a' or entry is not None and entry.removed: if state == b'a' or entry is not None and entry.removed:
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)
self._dirty = True self._dirty = True
self._updatedfiles.add(f) self._updatedfiles.add(f)
self._map.addfile( self._map.addfile(
f, f,
oldstate,
state=state, state=state,
mode=mode, mode=mode,
size=size, size=size,
mtime=mtime, mtime=mtime,
from_p2=from_p2, from_p2=from_p2,
possibly_dirty=possibly_dirty, possibly_dirty=possibly_dirty,
) )

mercurial/dirstatemap.py

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( def addfile(
self, self,
f, f,
oldstate,
state, state,
mode, mode,
size=None, size=None,
mtime=None, mtime=None,
from_p2=False, from_p2=False,
possibly_dirty=False, possibly_dirty=False,
): ):
"""Add a tracked file to the dirstate.""" """Add a tracked file to the dirstate."""
mtime = AMBIGUOUS_TIME mtime = AMBIGUOUS_TIME
else: else:
assert size != FROM_P2 assert size != FROM_P2
assert size != NONNORMAL assert size != NONNORMAL
size = size & rangemask size = size & rangemask
mtime = mtime & rangemask mtime = mtime & rangemask
assert size is not None assert size is not None
assert mtime is not None assert mtime is not None
if oldstate in b"?r" and "_dirs" in self.__dict__: old_entry = self.get(f)
if (
old_entry is None or old_entry.removed
) and "_dirs" in self.__dict__:
self._dirs.addpath(f) self._dirs.addpath(f)
if oldstate == b"?" and "_alldirs" in self.__dict__: if old_entry is None 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.otherparentset.add(f) self.otherparentset.add(f)
def removefile(self, f, in_merge=False): def removefile(self, f, in_merge=False):
b"experimental", b"experimental",
b"dirstate-tree.in-memory", b"dirstate-tree.in-memory",
False, False,
) )
def addfile( def addfile(
self, self,
f, f,
oldstate,
state, state,
mode, mode,
size=None, size=None,
mtime=None, mtime=None,
from_p2=False, from_p2=False,
possibly_dirty=False, possibly_dirty=False,
): ):
return self._rustmap.addfile( return self._rustmap.addfile(
f, f,
oldstate,
state, state,
mode, mode,
size, size,
mtime, mtime,
from_p2, from_p2,
possibly_dirty, possibly_dirty,
) )

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

self.non_normal_set = None; self.non_normal_set = None;
self.other_parent_set = None; self.other_parent_set = None;
} }
/// 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,
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
from_p2: bool, from_p2: bool,
possibly_dirty: bool, possibly_dirty: bool,
) -> Result<(), DirstateError> { ) -> Result<(), DirstateError> {
let mut entry = entry; let mut entry = entry;
if entry.state == EntryState::Added { if entry.state == EntryState::Added {
assert!(!possibly_dirty); assert!(!possibly_dirty);
assert!(!from_p2); assert!(!from_p2);
entry.size = SIZE_NON_NORMAL; entry.size = SIZE_NON_NORMAL;
entry.mtime = MTIME_UNSET; entry.mtime = MTIME_UNSET;
} else if from_p2 { } else if from_p2 {
assert!(!possibly_dirty); assert!(!possibly_dirty);
entry.size = SIZE_FROM_OTHER_PARENT; entry.size = SIZE_FROM_OTHER_PARENT;
entry.mtime = MTIME_UNSET; entry.mtime = MTIME_UNSET;
} else if possibly_dirty { } else if possibly_dirty {
entry.size = SIZE_NON_NORMAL; entry.size = SIZE_NON_NORMAL;
entry.mtime = MTIME_UNSET; entry.mtime = MTIME_UNSET;
} else { } else {
entry.size = entry.size & V1_RANGEMASK; entry.size = entry.size & V1_RANGEMASK;
entry.mtime = entry.mtime & V1_RANGEMASK; entry.mtime = entry.mtime & V1_RANGEMASK;
} }
let old_state = match self.get(filename) {
Some(e) => e.state,
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)?;
} }
} }
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 {
#[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"),
EntryState::Normal,
DirstateEntry { DirstateEntry {
state: EntryState::Normal, state: EntryState::Normal,
mode: 1337, mode: 1337,
mtime: 1337, mtime: 1337,
size: 1337, size: 1337,
}, },
false, false,
false, false,

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

self.root = Default::default(); self.root = Default::default();
self.nodes_with_entry_count = 0; self.nodes_with_entry_count = 0;
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,
entry: DirstateEntry, entry: DirstateEntry,
from_p2: bool, from_p2: bool,
possibly_dirty: bool, possibly_dirty: bool,
) -> Result<(), DirstateError> { ) -> Result<(), DirstateError> {
let mut entry = entry; let mut entry = entry;
if entry.state == EntryState::Added { if entry.state == EntryState::Added {
assert!(!possibly_dirty); assert!(!possibly_dirty);
assert!(!from_p2); assert!(!from_p2);
entry.size = SIZE_NON_NORMAL; entry.size = SIZE_NON_NORMAL;
entry.mtime = MTIME_UNSET; entry.mtime = MTIME_UNSET;
} else if from_p2 { } else if from_p2 {
assert!(!possibly_dirty); assert!(!possibly_dirty);
entry.size = SIZE_FROM_OTHER_PARENT; entry.size = SIZE_FROM_OTHER_PARENT;
entry.mtime = MTIME_UNSET; entry.mtime = MTIME_UNSET;
} else if possibly_dirty { } else if possibly_dirty {
entry.size = SIZE_NON_NORMAL; entry.size = SIZE_NON_NORMAL;
entry.mtime = MTIME_UNSET; entry.mtime = MTIME_UNSET;
} else { } else {
entry.size = entry.size & V1_RANGEMASK; entry.size = entry.size & V1_RANGEMASK;
entry.mtime = entry.mtime & V1_RANGEMASK; entry.mtime = entry.mtime & V1_RANGEMASK;
} }
let old_state = match self.get(filename)? {
Some(e) => e.state,
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> {

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

/// ///
/// `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.
/// ///
/// `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,
entry: DirstateEntry, entry: DirstateEntry,
from_p2: bool, from_p2: bool,
possibly_dirty: 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
impl DirstateMapMethods for DirstateMap { impl DirstateMapMethods for DirstateMap {
fn clear(&mut self) { fn clear(&mut self) {
self.clear() self.clear()
} }
fn add_file( fn add_file(
&mut self, &mut self,
filename: &HgPath, filename: &HgPath,
old_state: EntryState,
entry: DirstateEntry, entry: DirstateEntry,
from_p2: bool, from_p2: bool,
possibly_dirty: bool, possibly_dirty: bool,
) -> Result<(), DirstateError> { ) -> Result<(), DirstateError> {
self.add_file(filename, old_state, entry, from_p2, possibly_dirty) self.add_file(filename, 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

}, },
None => Ok(default) None => Ok(default)
} }
} }
def addfile( def addfile(
&self, &self,
f: PyObject, f: PyObject,
oldstate: PyObject,
state: PyObject, state: PyObject,
mode: PyObject, mode: PyObject,
size: PyObject, size: PyObject,
mtime: PyObject, mtime: PyObject,
from_p2: PyObject, from_p2: PyObject,
possibly_dirty: 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]
.try_into()
.map_err(|e: HgError| {
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 = if size.is_none(py) { let size = if size.is_none(py) {
// fallback default value // fallback default value
mode: mode, mode: mode,
size: size, size: size,
mtime: mtime, mtime: mtime,
}; };
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,
oldstate,
entry, entry,
from_p2, from_p2,
possibly_dirty 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()))
}) })
} }

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

impl DirstateMapMethods for OwningDirstateMap { impl DirstateMapMethods for OwningDirstateMap {
fn clear(&mut self) { fn clear(&mut self) {
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,
entry: DirstateEntry, entry: DirstateEntry,
from_p2: bool, from_p2: bool,
possibly_dirty: bool, possibly_dirty: bool,
) -> Result<(), DirstateError> { ) -> Result<(), DirstateError> {
self.get_mut().add_file( self.get_mut()
filename, .add_file(filename, entry, from_p2, possibly_dirty)
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)