( )⚙ D12530 rust-dirstatemap: use `get_node_mut` instead or `get_or_insert_node`

This is an archive of the discontinued Mercurial Phabricator instance.

Differential D12530

rust-dirstatemap: use `get_node_mut` instead or `get_or_insert_node`
Needs ReviewPublic

Authored by Alphare on Tue, Apr 12, 12:05 PM.

Details

Reviewers
None
Group Reviewers
hg-reviewers
Summary

This (along with the docstring), makes it more obvious that we're not expecting
to insert a node here. This is less prone to bugs in later refactorings.

Diff Detail

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

Revision Contents
Changeset List

Diff 33093

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

} else { } else {
node.data = NodeData::Entry(DirstateEntry::new_tracked()); node.data = NodeData::Entry(DirstateEntry::new_tracked());
self.nodes_with_entry_count += 1; self.nodes_with_entry_count += 1;
new = true; new = true;
}; };
Ok(new) Ok(new)
} }
/// It is the responsibility of the caller to know that there was an entry /// Set a node as untracked in the dirstate.
/// there before. Does not handle the removal of copy source ///
/// It is the responsibility of the caller to remove the copy source and/or
/// the entry itself if appropriate.
///
/// # Panics
///
/// Panics if the node does not exist.
fn set_untracked( fn set_untracked(
&mut self, &mut self,
filename: &HgPath, filename: &HgPath,
old_entry: DirstateEntry, old_entry: DirstateEntry,
) -> Result<(), DirstateV2ParseError> { ) -> Result<(), DirstateV2ParseError> {
let node = self.get_or_insert_node(filename, |ancestor| { let node = DirstateMap::get_node_mut(
self.on_disk,
&mut self.unreachable_bytes,
&mut self.root,
filename,
|ancestor| {
ancestor.tracked_descendants_count = ancestor ancestor.tracked_descendants_count = ancestor
.tracked_descendants_count .tracked_descendants_count
.checked_sub(1) .checked_sub(1)
.expect("tracked_descendants_count should be >= 0"); .expect("tracked_descendants_count should be >= 0");
})?; },
)?
.expect("node should exist");
let mut new_entry = old_entry.clone(); let mut new_entry = old_entry.clone();
new_entry.set_untracked(); new_entry.set_untracked();
node.data = NodeData::Entry(new_entry); node.data = NodeData::Entry(new_entry);
Ok(()) Ok(())
} }
/// Set a node as clean in the dirstate.
///
/// It is the responsibility of the caller to remove the copy source.
///
/// # Panics
///
/// Panics if the node does not exist.
fn set_clean( fn set_clean(
&mut self, &mut self,
filename: &HgPath, filename: &HgPath,
old_entry: DirstateEntry, old_entry: DirstateEntry,
mode: u32, mode: u32,
size: u32, size: u32,
mtime: TruncatedTimestamp, mtime: TruncatedTimestamp,
) -> Result<(), DirstateError> { ) -> Result<(), DirstateError> {
let node = self.get_or_insert_node(filename, |ancestor| { let node = DirstateMap::get_node_mut(
self.on_disk,
&mut self.unreachable_bytes,
&mut self.root,
filename,
|ancestor| {
if !old_entry.tracked() { if !old_entry.tracked() {
ancestor.tracked_descendants_count += 1; ancestor.tracked_descendants_count += 1;
} }
})?; },
)?
.expect("node should exist");
let mut new_entry = old_entry.clone(); let mut new_entry = old_entry.clone();
new_entry.set_clean(mode, size, mtime); new_entry.set_clean(mode, size, mtime);
node.data = NodeData::Entry(new_entry); node.data = NodeData::Entry(new_entry);
Ok(()) Ok(())
} }
/// Set a node as possibly dirty in the dirstate.
///
/// # Panics
///
/// Panics if the node does not exist.
fn set_possibly_dirty( fn set_possibly_dirty(
&mut self, &mut self,
filename: &HgPath, filename: &HgPath,
) -> Result<(), DirstateError> { ) -> Result<(), DirstateError> {
let node = self.get_or_insert_node(filename, |_ancestor| {})?; let node = DirstateMap::get_node_mut(
self.on_disk,
&mut self.unreachable_bytes,
&mut self.root,
filename,
|_ancestor| {},
)?
.expect("node should exist");
let entry = node.data.as_entry_mut().expect("entry should exist"); let entry = node.data.as_entry_mut().expect("entry should exist");
entry.set_possibly_dirty(); entry.set_possibly_dirty();
node.data = NodeData::Entry(*entry); node.data = NodeData::Entry(*entry);
Ok(()) Ok(())
} }
/// Clears the cached mtime for the (potential) folder at `path`. /// Clears the cached mtime for the (potential) folder at `path`.
pub(super) fn clear_cached_mtime( pub(super) fn clear_cached_mtime(