( )⚙ 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
Branch
default
Lint
No Linters Available
Unit
No Unit Test Coverage

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 28787

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)