This is an archive of the discontinued Mercurial Phabricator instance.

Differential D12449

rust-dirstatemap: add `set_tracked` method
ClosedPublic

Authored by Alphare on Apr 6 2022, 10:10 AM.

Details

Reviewers
marmoute
Group Reviewers
hg-reviewers
Commits
rHGd48e4c801515: rust-dirstatemap: add `set_tracked` method
rHG77bdd89ca2d7: rust-dirstatemap: add `set_tracked` method
Summary

This is the new dirstate API that has already been moved to in Python.
It will be used in place of the old addfile/removefile one.

Diff Detail

Repository
rHG Mercurial
Branch
default
Lint
No Linters Available
Unit
No Unit Test Coverage

Event Timeline

Alphare created this revision.Apr 6 2022, 10:10 AM
marmoute accepted this revision.Apr 8 2022, 6:53 AM
Alphare added inline comments.Apr 8 2022, 6:56 AM
rust/hg-core/src/dirstate_tree/dirstate_map.rs
614

Now that I see it, this really shouldn't call e.state(), but should use e.tracked() directly

Alphare added a commit: rHG77bdd89ca2d7: rust-dirstatemap: add `set_tracked` method.Apr 8 2022, 11:55 AM
This revision was not accepted when it landed; it landed in state Needs Review.
Closed by commit rHG77bdd89ca2d7: rust-dirstatemap: add `set_tracked` method (authored by Alphare). · Explain Why
This revision was automatically updated to reflect the committed changes.
baymax updated this revision to Diff 32921.Apr 8 2022, 12:29 PM

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

baymax updated this revision to Diff 33023.Apr 12 2022, 10:57 AM

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

baymax updated this revision to Diff 33102.Apr 12 2022, 12:05 PM

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

Revision Contents
Changeset List

Diff 33102

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

/// Creates a new entry in "removed" state. /// Creates a new entry in "removed" state.
/// ///
/// `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 {
Self::from_v2_data(true, false, false, None, None, None, None)
}
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)
} }

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

ancestor_path = next; ancestor_path = next;
child_nodes = &mut child_node.children; child_nodes = &mut child_node.children;
} else { } else {
return Ok(child_node); return Ok(child_node);
} }
} }
} }
fn set_tracked(
&mut self,
filename: &HgPath,
old_entry_opt: Option<DirstateEntry>,
) -> Result<bool, DirstateV2ParseError> {
let was_tracked = old_entry_opt.map_or(false, |e| e.tracked());
AlphareAuthorUnsubmitted
Done

Now that I see it, this really shouldn't call e.state(), but should use e.tracked() directly

Alphare: Now that I see it, this really shouldn't call `e.state()`, but should use `e.tracked()` directly
let had_entry = old_entry_opt.is_some();
let tracked_count_increment = if was_tracked { 0 } else { 1 };
let mut new = false;
let node = Self::get_or_insert_node(
self.on_disk,
&mut self.unreachable_bytes,
&mut self.root,
filename,
WithBasename::to_cow_owned,
|ancestor| {
if !had_entry {
ancestor.descendants_with_entry_count += 1;
}
ancestor.tracked_descendants_count += tracked_count_increment;
},
)?;
let new_entry = if let Some(old_entry) = old_entry_opt {
let mut e = old_entry.clone();
if e.tracked() {
// XXX
// This is probably overkill for more case, but we need this to
// fully replace the `normallookup` call with `set_tracked`
// one. Consider smoothing this in the future.
e.set_possibly_dirty();
} else {
new = true;
e.set_tracked();
}
e
} else {
self.nodes_with_entry_count += 1;
new = true;
DirstateEntry::new_tracked()
};
node.data = NodeData::Entry(new_entry);
Ok(new)
}
fn add_or_remove_file( fn add_or_remove_file(
&mut self, &mut self,
path: &HgPath, path: &HgPath,
old_state: Option<EntryState>, old_state: Option<EntryState>,
new_entry: DirstateEntry, new_entry: DirstateEntry,
) -> Result<(), DirstateV2ParseError> { ) -> Result<(), DirstateV2ParseError> {
let had_entry = old_state.is_some(); let had_entry = old_state.is_some();
let was_tracked = old_state.map_or(false, |s| s.is_tracked()); let was_tracked = old_state.map_or(false, |s| s.is_tracked());
entry: DirstateEntry, entry: DirstateEntry,
) -> Result<(), DirstateError> { ) -> Result<(), DirstateError> {
let old_state = self.get(filename)?.map(|e| e.state()); let old_state = self.get(filename)?.map(|e| e.state());
self.with_dmap_mut(|map| { self.with_dmap_mut(|map| {
Ok(map.add_or_remove_file(filename, old_state, entry)?) Ok(map.add_or_remove_file(filename, old_state, entry)?)
}) })
} }
pub fn set_tracked(
&mut self,
filename: &HgPath,
) -> Result<bool, DirstateV2ParseError> {
let old_entry_opt = self.get(filename)?;
self.with_dmap_mut(|map| map.set_tracked(filename, old_entry_opt))
}
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 = old_entry_opt.map(|e| e.state()); let old_state = old_entry_opt.map(|e| e.state());
let mut size = 0; let mut size = 0;