| Alphare |
| hg-reviewers |
| Automatic diff as part of commit; lint not applicable. |
| Automatic diff as part of commit; unit tests not applicable. |
| Path | Packages | |||
|---|---|---|---|---|
| M | rust/hg-core/src/dirstate_tree/dirstate_map.rs (91 lines) | |||
| M | rust/hg-core/src/dirstate_tree/on_disk.rs (27 lines) | |||
| M | rust/hg-core/src/dirstate_tree/status.rs (30 lines) |
| Status | Author | Revision | |
|---|---|---|---|
| Closed | SimonSapin | ||
| Closed | SimonSapin | ||
| Closed | SimonSapin | ||
| Closed | SimonSapin | ||
| Closed | SimonSapin | ||
| Closed | SimonSapin | ||
| Closed | SimonSapin | ||
| Closed | SimonSapin | ||
| Closed | SimonSapin |
| pub(super) fn is_empty(&self) -> bool { | pub(super) fn is_empty(&self) -> bool { | ||||
| match self { | match self { | ||||
| ChildNodes::InMemory(nodes) => nodes.is_empty(), | ChildNodes::InMemory(nodes) => nodes.is_empty(), | ||||
| } | } | ||||
| } | } | ||||
| pub(super) fn make_mut( | pub(super) fn make_mut( | ||||
| &mut self, | &mut self, | ||||
| _on_disk: &'on_disk [u8], | |||||
| ) -> Result< | ) -> Result< | ||||
| &mut FastHashMap<NodeKey<'on_disk>, Node<'on_disk>>, | &mut FastHashMap<NodeKey<'on_disk>, Node<'on_disk>>, | ||||
| DirstateV2ParseError, | DirstateV2ParseError, | ||||
| > { | > { | ||||
| match self { | match self { | ||||
| ChildNodes::InMemory(nodes) => Ok(nodes), | ChildNodes::InMemory(nodes) => Ok(nodes), | ||||
| } | } | ||||
| } | } | ||||
| } | } | ||||
| impl<'tree, 'on_disk> ChildNodesRef<'tree, 'on_disk> { | impl<'tree, 'on_disk> ChildNodesRef<'tree, 'on_disk> { | ||||
| pub(super) fn get( | pub(super) fn get( | ||||
| &self, | &self, | ||||
| base_name: &HgPath, | base_name: &HgPath, | ||||
| _on_disk: &'on_disk [u8], | |||||
| ) -> Result<Option<NodeRef<'tree, 'on_disk>>, DirstateV2ParseError> { | ) -> Result<Option<NodeRef<'tree, 'on_disk>>, DirstateV2ParseError> { | ||||
| match self { | match self { | ||||
| ChildNodesRef::InMemory(nodes) => Ok(nodes | ChildNodesRef::InMemory(nodes) => Ok(nodes | ||||
| .get_key_value(base_name) | .get_key_value(base_name) | ||||
| .map(|(k, v)| NodeRef::InMemory(k, v))), | .map(|(k, v)| NodeRef::InMemory(k, v))), | ||||
| } | } | ||||
| } | } | ||||
| } | } | ||||
| } | } | ||||
| } | } | ||||
| } | } | ||||
| impl<'tree, 'on_disk> NodeRef<'tree, 'on_disk> { | impl<'tree, 'on_disk> NodeRef<'tree, 'on_disk> { | ||||
| pub(super) fn full_path( | pub(super) fn full_path( | ||||
| &self, | &self, | ||||
| _on_disk: &'on_disk [u8], | |||||
| ) -> Result<&'tree HgPath, DirstateV2ParseError> { | ) -> Result<&'tree HgPath, DirstateV2ParseError> { | ||||
| match self { | match self { | ||||
| NodeRef::InMemory(path, _node) => Ok(path.full_path()), | NodeRef::InMemory(path, _node) => Ok(path.full_path()), | ||||
| } | } | ||||
| } | } | ||||
| /// Returns a `Cow` that can borrow 'on_disk but is detached from 'tree | /// Returns a `Cow` that can borrow 'on_disk but is detached from 'tree | ||||
| pub(super) fn full_path_cow( | pub(super) fn full_path_cow( | ||||
| &self, | &self, | ||||
| _on_disk: &'on_disk [u8], | |||||
| ) -> Result<Cow<'on_disk, HgPath>, DirstateV2ParseError> { | ) -> Result<Cow<'on_disk, HgPath>, DirstateV2ParseError> { | ||||
| match self { | match self { | ||||
| NodeRef::InMemory(path, _node) => Ok(path.full_path().clone()), | NodeRef::InMemory(path, _node) => Ok(path.full_path().clone()), | ||||
| } | } | ||||
| } | } | ||||
| pub(super) fn base_name( | pub(super) fn base_name( | ||||
| &self, | &self, | ||||
| _on_disk: &'on_disk [u8], | |||||
| ) -> Result<&'tree HgPath, DirstateV2ParseError> { | ) -> Result<&'tree HgPath, DirstateV2ParseError> { | ||||
| match self { | match self { | ||||
| NodeRef::InMemory(path, _node) => Ok(path.base_name()), | NodeRef::InMemory(path, _node) => Ok(path.base_name()), | ||||
| } | } | ||||
| } | } | ||||
| pub(super) fn children( | pub(super) fn children( | ||||
| &self, | &self, | ||||
| _on_disk: &'on_disk [u8], | |||||
| ) -> Result<ChildNodesRef<'tree, 'on_disk>, DirstateV2ParseError> { | ) -> Result<ChildNodesRef<'tree, 'on_disk>, DirstateV2ParseError> { | ||||
| match self { | match self { | ||||
| NodeRef::InMemory(_path, node) => Ok(node.children.as_ref()), | NodeRef::InMemory(_path, node) => Ok(node.children.as_ref()), | ||||
| } | } | ||||
| } | } | ||||
| pub(super) fn has_copy_source(&self) -> bool { | pub(super) fn has_copy_source(&self) -> bool { | ||||
| match self { | match self { | ||||
| NodeRef::InMemory(_path, node) => node.copy_source.is_some(), | NodeRef::InMemory(_path, node) => node.copy_source.is_some(), | ||||
| } | } | ||||
| } | } | ||||
| pub(super) fn copy_source( | pub(super) fn copy_source( | ||||
| &self, | &self, | ||||
| _on_disk: &'on_disk [u8], | |||||
| ) -> Result<Option<&'tree HgPath>, DirstateV2ParseError> { | ) -> Result<Option<&'tree HgPath>, DirstateV2ParseError> { | ||||
| match self { | match self { | ||||
| NodeRef::InMemory(_path, node) => { | NodeRef::InMemory(_path, node) => { | ||||
| Ok(node.copy_source.as_ref().map(|s| &**s)) | Ok(node.copy_source.as_ref().map(|s| &**s)) | ||||
| } | } | ||||
| } | } | ||||
| } | } | ||||
| return Ok((map, None)); | return Ok((map, None)); | ||||
| } | } | ||||
| let parents = parse_dirstate_entries( | let parents = parse_dirstate_entries( | ||||
| map.on_disk, | map.on_disk, | ||||
| |path, entry, copy_source| { | |path, entry, copy_source| { | ||||
| let tracked = entry.state.is_tracked(); | let tracked = entry.state.is_tracked(); | ||||
| let node = Self::get_or_insert_node( | let node = Self::get_or_insert_node( | ||||
| map.on_disk, | |||||
| &mut map.root, | &mut map.root, | ||||
| path, | path, | ||||
| WithBasename::to_cow_borrowed, | WithBasename::to_cow_borrowed, | ||||
| |ancestor| { | |ancestor| { | ||||
| if tracked { | if tracked { | ||||
| ancestor.tracked_descendants_count += 1 | ancestor.tracked_descendants_count += 1 | ||||
| } | } | ||||
| }, | }, | ||||
| &'tree self, | &'tree self, | ||||
| path: &HgPath, | path: &HgPath, | ||||
| ) -> Result<Option<NodeRef<'tree, 'on_disk>>, DirstateV2ParseError> { | ) -> Result<Option<NodeRef<'tree, 'on_disk>>, DirstateV2ParseError> { | ||||
| let mut children = self.root.as_ref(); | let mut children = self.root.as_ref(); | ||||
| let mut components = path.components(); | let mut components = path.components(); | ||||
| let mut component = | let mut component = | ||||
| components.next().expect("expected at least one components"); | components.next().expect("expected at least one components"); | ||||
| loop { | loop { | ||||
| if let Some(child) = children.get(component)? { | if let Some(child) = children.get(component, self.on_disk)? { | ||||
| if let Some(next_component) = components.next() { | if let Some(next_component) = components.next() { | ||||
| component = next_component; | component = next_component; | ||||
| children = child.children()?; | children = child.children(self.on_disk)?; | ||||
| } else { | } else { | ||||
| return Ok(Some(child)); | return Ok(Some(child)); | ||||
| } | } | ||||
| } else { | } else { | ||||
| return Ok(None); | return Ok(None); | ||||
| } | } | ||||
| } | } | ||||
| } | } | ||||
| /// Returns a mutable reference to the node at `path` if it exists | /// Returns a mutable reference to the node at `path` if it exists | ||||
| /// | /// | ||||
| /// This takes `root` instead of `&mut self` so that callers can mutate | /// This takes `root` instead of `&mut self` so that callers can mutate | ||||
| /// other fields while the returned borrow is still valid | /// other fields while the returned borrow is still valid | ||||
| fn get_node_mut<'tree>( | fn get_node_mut<'tree>( | ||||
| on_disk: &'on_disk [u8], | |||||
| root: &'tree mut ChildNodes<'on_disk>, | root: &'tree mut ChildNodes<'on_disk>, | ||||
| path: &HgPath, | path: &HgPath, | ||||
| ) -> Result<Option<&'tree mut Node<'on_disk>>, DirstateV2ParseError> { | ) -> Result<Option<&'tree mut Node<'on_disk>>, DirstateV2ParseError> { | ||||
| let mut children = root; | let mut children = root; | ||||
| let mut components = path.components(); | let mut components = path.components(); | ||||
| let mut component = | let mut component = | ||||
| components.next().expect("expected at least one components"); | components.next().expect("expected at least one components"); | ||||
| loop { | loop { | ||||
| if let Some(child) = children.make_mut()?.get_mut(component) { | if let Some(child) = children.make_mut(on_disk)?.get_mut(component) | ||||
| { | |||||
| if let Some(next_component) = components.next() { | if let Some(next_component) = components.next() { | ||||
| component = next_component; | component = next_component; | ||||
| children = &mut child.children; | children = &mut child.children; | ||||
| } else { | } else { | ||||
| return Ok(Some(child)); | return Ok(Some(child)); | ||||
| } | } | ||||
| } else { | } else { | ||||
| return Ok(None); | return Ok(None); | ||||
| } | } | ||||
| } | } | ||||
| } | } | ||||
| fn get_or_insert_node<'tree, 'path>( | fn get_or_insert_node<'tree, 'path>( | ||||
| on_disk: &'on_disk [u8], | |||||
| root: &'tree mut ChildNodes<'on_disk>, | root: &'tree mut ChildNodes<'on_disk>, | ||||
| path: &'path HgPath, | path: &'path HgPath, | ||||
| to_cow: impl Fn( | to_cow: impl Fn( | ||||
| WithBasename<&'path HgPath>, | WithBasename<&'path HgPath>, | ||||
| ) -> WithBasename<Cow<'on_disk, HgPath>>, | ) -> WithBasename<Cow<'on_disk, HgPath>>, | ||||
| mut each_ancestor: impl FnMut(&mut Node), | mut each_ancestor: impl FnMut(&mut Node), | ||||
| ) -> Result<&'tree mut Node<'on_disk>, DirstateV2ParseError> { | ) -> Result<&'tree mut Node<'on_disk>, DirstateV2ParseError> { | ||||
| let mut child_nodes = root; | let mut child_nodes = root; | ||||
| let mut inclusive_ancestor_paths = | let mut inclusive_ancestor_paths = | ||||
| WithBasename::inclusive_ancestors_of(path); | WithBasename::inclusive_ancestors_of(path); | ||||
| let mut ancestor_path = inclusive_ancestor_paths | let mut ancestor_path = inclusive_ancestor_paths | ||||
| .next() | .next() | ||||
| .expect("expected at least one inclusive ancestor"); | .expect("expected at least one inclusive ancestor"); | ||||
| loop { | loop { | ||||
| // TODO: can we avoid allocating an owned key in cases where the | // TODO: can we avoid allocating an owned key in cases where the | ||||
| // map already contains that key, without introducing double | // map already contains that key, without introducing double | ||||
| // lookup? | // lookup? | ||||
| let child_node = child_nodes | let child_node = child_nodes | ||||
| .make_mut()? | .make_mut(on_disk)? | ||||
| .entry(to_cow(ancestor_path)) | .entry(to_cow(ancestor_path)) | ||||
| .or_default(); | .or_default(); | ||||
| if let Some(next) = inclusive_ancestor_paths.next() { | if let Some(next) = inclusive_ancestor_paths.next() { | ||||
| each_ancestor(child_node); | each_ancestor(child_node); | ||||
| 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); | ||||
| let tracked_count_increment = | let tracked_count_increment = | ||||
| match (old_state.is_tracked(), new_entry.state.is_tracked()) { | match (old_state.is_tracked(), new_entry.state.is_tracked()) { | ||||
| (false, true) => 1, | (false, true) => 1, | ||||
| (true, false) => -1, | (true, false) => -1, | ||||
| _ => 0, | _ => 0, | ||||
| }; | }; | ||||
| let node = Self::get_or_insert_node( | let node = Self::get_or_insert_node( | ||||
| self.on_disk, | |||||
| &mut self.root, | &mut self.root, | ||||
| path, | path, | ||||
| WithBasename::to_cow_owned, | WithBasename::to_cow_owned, | ||||
| |ancestor| { | |ancestor| { | ||||
| // We can’t use `+= increment` because the counter is unsigned, | // We can’t use `+= increment` because the counter is unsigned, | ||||
| // and we want debug builds to detect accidental underflow | // and we want debug builds to detect accidental underflow | ||||
| // through zero | // through zero | ||||
| match tracked_count_increment { | match tracked_count_increment { | ||||
| // ``` | // ``` | ||||
| // | // | ||||
| // However we want an external iterator and therefore can’t use the | // However we want an external iterator and therefore can’t use the | ||||
| // call stack. Use an explicit stack instead: | // call stack. Use an explicit stack instead: | ||||
| let mut stack = Vec::new(); | let mut stack = Vec::new(); | ||||
| let mut iter = self.root.as_ref().iter(); | let mut iter = self.root.as_ref().iter(); | ||||
| std::iter::from_fn(move || { | std::iter::from_fn(move || { | ||||
| while let Some(child_node) = iter.next() { | while let Some(child_node) = iter.next() { | ||||
| let children = match child_node.children() { | let children = match child_node.children(self.on_disk) { | ||||
| Ok(children) => children, | Ok(children) => children, | ||||
| Err(error) => return Some(Err(error)), | Err(error) => return Some(Err(error)), | ||||
| }; | }; | ||||
| // Pseudo-recursion | // Pseudo-recursion | ||||
| let new_iter = children.iter(); | let new_iter = children.iter(); | ||||
| let old_iter = std::mem::replace(&mut iter, new_iter); | let old_iter = std::mem::replace(&mut iter, new_iter); | ||||
| stack.push((child_node, old_iter)); | stack.push((child_node, old_iter)); | ||||
| } | } | ||||
| }) | }) | ||||
| } | } | ||||
| fn clear_known_ambiguous_mtimes( | fn clear_known_ambiguous_mtimes( | ||||
| &mut self, | &mut self, | ||||
| paths: &[impl AsRef<HgPath>], | paths: &[impl AsRef<HgPath>], | ||||
| ) -> Result<(), DirstateV2ParseError> { | ) -> Result<(), DirstateV2ParseError> { | ||||
| for path in paths { | for path in paths { | ||||
| if let Some(node) = | if let Some(node) = Self::get_node_mut( | ||||
| Self::get_node_mut(&mut self.root, path.as_ref())? | self.on_disk, | ||||
| { | &mut self.root, | ||||
| path.as_ref(), | |||||
| )? { | |||||
| if let Some(entry) = node.entry.as_mut() { | if let Some(entry) = node.entry.as_mut() { | ||||
| entry.clear_mtime(); | entry.clear_mtime(); | ||||
| } | } | ||||
| } | } | ||||
| } | } | ||||
| Ok(()) | Ok(()) | ||||
| } | } | ||||
| /// Return a faillilble iterator of full paths of nodes that have an | /// Return a faillilble iterator of full paths of nodes that have an | ||||
| /// `entry` for which the given `predicate` returns true. | /// `entry` for which the given `predicate` returns true. | ||||
| /// | /// | ||||
| /// Fallibility means that each iterator item is a `Result`, which may | /// Fallibility means that each iterator item is a `Result`, which may | ||||
| /// indicate a parse error of the on-disk dirstate-v2 format. Such errors | /// indicate a parse error of the on-disk dirstate-v2 format. Such errors | ||||
| /// should only happen if Mercurial is buggy or a repository is corrupted. | /// should only happen if Mercurial is buggy or a repository is corrupted. | ||||
| fn filter_full_paths<'tree>( | fn filter_full_paths<'tree>( | ||||
| &'tree self, | &'tree self, | ||||
| predicate: impl Fn(&DirstateEntry) -> bool + 'tree, | predicate: impl Fn(&DirstateEntry) -> bool + 'tree, | ||||
| ) -> impl Iterator<Item = Result<&HgPath, DirstateV2ParseError>> + 'tree | ) -> impl Iterator<Item = Result<&HgPath, DirstateV2ParseError>> + 'tree | ||||
| { | { | ||||
| filter_map_results(self.iter_nodes(), move |node| { | filter_map_results(self.iter_nodes(), move |node| { | ||||
| if let Some(entry) = node.entry()? { | if let Some(entry) = node.entry()? { | ||||
| if predicate(&entry) { | if predicate(&entry) { | ||||
| return Ok(Some(node.full_path()?)); | return Ok(Some(node.full_path(self.on_disk)?)); | ||||
| } | } | ||||
| } | } | ||||
| Ok(None) | Ok(None) | ||||
| }) | }) | ||||
| } | } | ||||
| } | } | ||||
| /// Like `Iterator::filter_map`, but over a fallible iterator of `Result`s. | /// Like `Iterator::filter_map`, but over a fallible iterator of `Result`s. | ||||
| filename: &HgPath, | filename: &HgPath, | ||||
| old_state: EntryState, | old_state: EntryState, | ||||
| ) -> Result<bool, DirstateError> { | ) -> Result<bool, DirstateError> { | ||||
| struct Dropped { | struct Dropped { | ||||
| was_tracked: bool, | was_tracked: bool, | ||||
| had_entry: bool, | had_entry: bool, | ||||
| had_copy_source: bool, | had_copy_source: bool, | ||||
| } | } | ||||
| fn recur( | fn recur<'on_disk>( | ||||
| nodes: &mut ChildNodes, | on_disk: &'on_disk [u8], | ||||
| nodes: &mut ChildNodes<'on_disk>, | |||||
| path: &HgPath, | path: &HgPath, | ||||
| ) -> Result<Option<Dropped>, DirstateV2ParseError> { | ) -> Result<Option<Dropped>, DirstateV2ParseError> { | ||||
| let (first_path_component, rest_of_path) = | let (first_path_component, rest_of_path) = | ||||
| path.split_first_component(); | path.split_first_component(); | ||||
| let node = if let Some(node) = | let node = if let Some(node) = | ||||
| nodes.make_mut()?.get_mut(first_path_component) | nodes.make_mut(on_disk)?.get_mut(first_path_component) | ||||
| { | { | ||||
| node | node | ||||
| } else { | } else { | ||||
| return Ok(None); | return Ok(None); | ||||
| }; | }; | ||||
| let dropped; | let dropped; | ||||
| if let Some(rest) = rest_of_path { | if let Some(rest) = rest_of_path { | ||||
| if let Some(d) = recur(&mut node.children, rest)? { | if let Some(d) = recur(on_disk, &mut node.children, rest)? { | ||||
| dropped = d; | dropped = d; | ||||
| if dropped.was_tracked { | if dropped.was_tracked { | ||||
| node.tracked_descendants_count -= 1; | node.tracked_descendants_count -= 1; | ||||
| } | } | ||||
| } else { | } else { | ||||
| return Ok(None); | return Ok(None); | ||||
| } | } | ||||
| } else { | } else { | ||||
| dropped = Dropped { | dropped = Dropped { | ||||
| was_tracked: node | was_tracked: node | ||||
| .entry | .entry | ||||
| .as_ref() | .as_ref() | ||||
| .map_or(false, |entry| entry.state.is_tracked()), | .map_or(false, |entry| entry.state.is_tracked()), | ||||
| had_entry: node.entry.take().is_some(), | had_entry: node.entry.take().is_some(), | ||||
| had_copy_source: node.copy_source.take().is_some(), | had_copy_source: node.copy_source.take().is_some(), | ||||
| }; | }; | ||||
| } | } | ||||
| // After recursion, for both leaf (rest_of_path is None) nodes and | // After recursion, for both leaf (rest_of_path is None) nodes and | ||||
| // parent nodes, remove a node if it just became empty. | // parent nodes, remove a node if it just became empty. | ||||
| if node.entry.is_none() | if node.entry.is_none() | ||||
| && node.copy_source.is_none() | && node.copy_source.is_none() | ||||
| && node.children.is_empty() | && node.children.is_empty() | ||||
| { | { | ||||
| nodes.make_mut()?.remove(first_path_component); | nodes.make_mut(on_disk)?.remove(first_path_component); | ||||
| } | } | ||||
| Ok(Some(dropped)) | Ok(Some(dropped)) | ||||
| } | } | ||||
| if let Some(dropped) = recur(&mut self.root, filename)? { | if let Some(dropped) = recur(self.on_disk, &mut self.root, filename)? { | ||||
| if dropped.had_entry { | if dropped.had_entry { | ||||
| self.nodes_with_entry_count -= 1 | self.nodes_with_entry_count -= 1 | ||||
| } | } | ||||
| if dropped.had_copy_source { | if dropped.had_copy_source { | ||||
| self.nodes_with_copy_source_count -= 1 | self.nodes_with_copy_source_count -= 1 | ||||
| } | } | ||||
| Ok(dropped.had_entry) | Ok(dropped.had_entry) | ||||
| } else { | } else { | ||||
| debug_assert!(!old_state.is_tracked()); | debug_assert!(!old_state.is_tracked()); | ||||
| Ok(false) | Ok(false) | ||||
| } | } | ||||
| } | } | ||||
| fn clear_ambiguous_times( | fn clear_ambiguous_times( | ||||
| &mut self, | &mut self, | ||||
| filenames: Vec<HgPathBuf>, | filenames: Vec<HgPathBuf>, | ||||
| now: i32, | now: i32, | ||||
| ) -> Result<(), DirstateV2ParseError> { | ) -> Result<(), DirstateV2ParseError> { | ||||
| for filename in filenames { | for filename in filenames { | ||||
| if let Some(node) = Self::get_node_mut(&mut self.root, &filename)? | if let Some(node) = | ||||
| Self::get_node_mut(self.on_disk, &mut self.root, &filename)? | |||||
| { | { | ||||
| if let Some(entry) = node.entry.as_mut() { | if let Some(entry) = node.entry.as_mut() { | ||||
| entry.clear_ambiguous_mtime(now); | entry.clear_ambiguous_mtime(now); | ||||
| } | } | ||||
| } | } | ||||
| } | } | ||||
| Ok(()) | Ok(()) | ||||
| } | } | ||||
| let now: i32 = now.0.try_into().expect("time overflow"); | let now: i32 = now.0.try_into().expect("time overflow"); | ||||
| let mut ambiguous_mtimes = Vec::new(); | let mut ambiguous_mtimes = Vec::new(); | ||||
| // Optizimation (to be measured?): pre-compute size to avoid `Vec` | // Optizimation (to be measured?): pre-compute size to avoid `Vec` | ||||
| // reallocations | // reallocations | ||||
| let mut size = parents.as_bytes().len(); | let mut size = parents.as_bytes().len(); | ||||
| for node in self.iter_nodes() { | for node in self.iter_nodes() { | ||||
| let node = node?; | let node = node?; | ||||
| if let Some(entry) = node.entry()? { | if let Some(entry) = node.entry()? { | ||||
| size += | size += packed_entry_size( | ||||
| packed_entry_size(node.full_path()?, node.copy_source()?); | node.full_path(self.on_disk)?, | ||||
| node.copy_source(self.on_disk)?, | |||||
| ); | |||||
| if entry.mtime_is_ambiguous(now) { | if entry.mtime_is_ambiguous(now) { | ||||
| ambiguous_mtimes.push(node.full_path_cow()?) | ambiguous_mtimes.push(node.full_path_cow(self.on_disk)?) | ||||
| } | } | ||||
| } | } | ||||
| } | } | ||||
| self.clear_known_ambiguous_mtimes(&ambiguous_mtimes)?; | self.clear_known_ambiguous_mtimes(&ambiguous_mtimes)?; | ||||
| let mut packed = Vec::with_capacity(size); | let mut packed = Vec::with_capacity(size); | ||||
| packed.extend(parents.as_bytes()); | packed.extend(parents.as_bytes()); | ||||
| for node in self.iter_nodes() { | for node in self.iter_nodes() { | ||||
| let node = node?; | let node = node?; | ||||
| if let Some(entry) = node.entry()? { | if let Some(entry) = node.entry()? { | ||||
| pack_entry( | pack_entry( | ||||
| node.full_path()?, | node.full_path(self.on_disk)?, | ||||
| &entry, | &entry, | ||||
| node.copy_source()?, | node.copy_source(self.on_disk)?, | ||||
| &mut packed, | &mut packed, | ||||
| ); | ); | ||||
| } | } | ||||
| } | } | ||||
| Ok(packed) | Ok(packed) | ||||
| } | } | ||||
| #[timed] | #[timed] | ||||
| fn pack_v2( | fn pack_v2( | ||||
| &mut self, | &mut self, | ||||
| parents: DirstateParents, | parents: DirstateParents, | ||||
| now: Timestamp, | now: Timestamp, | ||||
| ) -> Result<Vec<u8>, DirstateError> { | ) -> Result<Vec<u8>, DirstateError> { | ||||
| // TODO:!how do we want to handle this in 2038? | // TODO:!how do we want to handle this in 2038? | ||||
| let now: i32 = now.0.try_into().expect("time overflow"); | let now: i32 = now.0.try_into().expect("time overflow"); | ||||
| let mut paths = Vec::new(); | let mut paths = Vec::new(); | ||||
| for node in self.iter_nodes() { | for node in self.iter_nodes() { | ||||
| let node = node?; | let node = node?; | ||||
| if let Some(entry) = node.entry()? { | if let Some(entry) = node.entry()? { | ||||
| if entry.mtime_is_ambiguous(now) { | if entry.mtime_is_ambiguous(now) { | ||||
| paths.push(node.full_path_cow()?) | paths.push(node.full_path_cow(self.on_disk)?) | ||||
| } | } | ||||
| } | } | ||||
| } | } | ||||
| // Borrow of `self` ends here since we collect cloned paths | // Borrow of `self` ends here since we collect cloned paths | ||||
| self.clear_known_ambiguous_mtimes(&paths)?; | self.clear_known_ambiguous_mtimes(&paths)?; | ||||
| on_disk::write(self, parents) | on_disk::write(self, parents) | ||||
| super::status::status(self, matcher, root_dir, ignore_files, options) | super::status::status(self, matcher, root_dir, ignore_files, options) | ||||
| } | } | ||||
| fn copy_map_len(&self) -> usize { | fn copy_map_len(&self) -> usize { | ||||
| self.nodes_with_copy_source_count as usize | self.nodes_with_copy_source_count as usize | ||||
| } | } | ||||
| fn copy_map_iter(&self) -> CopyMapIter<'_> { | fn copy_map_iter(&self) -> CopyMapIter<'_> { | ||||
| Box::new(filter_map_results(self.iter_nodes(), |node| { | Box::new(filter_map_results(self.iter_nodes(), move |node| { | ||||
| Ok(if let Some(source) = node.copy_source()? { | Ok(if let Some(source) = node.copy_source(self.on_disk)? { | ||||
| Some((node.full_path()?, source)) | Some((node.full_path(self.on_disk)?, source)) | ||||
| } else { | } else { | ||||
| None | None | ||||
| }) | }) | ||||
| })) | })) | ||||
| } | } | ||||
| fn copy_map_contains_key( | fn copy_map_contains_key( | ||||
| &self, | &self, | ||||
| key: &HgPath, | key: &HgPath, | ||||
| ) -> Result<bool, DirstateV2ParseError> { | ) -> Result<bool, DirstateV2ParseError> { | ||||
| Ok(if let Some(node) = self.get_node(key)? { | Ok(if let Some(node) = self.get_node(key)? { | ||||
| node.has_copy_source() | node.has_copy_source() | ||||
| } else { | } else { | ||||
| false | false | ||||
| }) | }) | ||||
| } | } | ||||
| fn copy_map_get( | fn copy_map_get( | ||||
| &self, | &self, | ||||
| key: &HgPath, | key: &HgPath, | ||||
| ) -> Result<Option<&HgPath>, DirstateV2ParseError> { | ) -> Result<Option<&HgPath>, DirstateV2ParseError> { | ||||
| if let Some(node) = self.get_node(key)? { | if let Some(node) = self.get_node(key)? { | ||||
| if let Some(source) = node.copy_source()? { | if let Some(source) = node.copy_source(self.on_disk)? { | ||||
| return Ok(Some(source)); | return Ok(Some(source)); | ||||
| } | } | ||||
| } | } | ||||
| Ok(None) | Ok(None) | ||||
| } | } | ||||
| fn copy_map_remove( | fn copy_map_remove( | ||||
| &mut self, | &mut self, | ||||
| key: &HgPath, | key: &HgPath, | ||||
| ) -> Result<Option<HgPathBuf>, DirstateV2ParseError> { | ) -> Result<Option<HgPathBuf>, DirstateV2ParseError> { | ||||
| let count = &mut self.nodes_with_copy_source_count; | let count = &mut self.nodes_with_copy_source_count; | ||||
| Ok(Self::get_node_mut(&mut self.root, key)?.and_then(|node| { | Ok( | ||||
| Self::get_node_mut(self.on_disk, &mut self.root, key)?.and_then( | |||||
| |node| { | |||||
| if node.copy_source.is_some() { | if node.copy_source.is_some() { | ||||
| *count -= 1 | *count -= 1 | ||||
| } | } | ||||
| node.copy_source.take().map(Cow::into_owned) | node.copy_source.take().map(Cow::into_owned) | ||||
| })) | }, | ||||
| ), | |||||
| ) | |||||
| } | } | ||||
| fn copy_map_insert( | fn copy_map_insert( | ||||
| &mut self, | &mut self, | ||||
| key: HgPathBuf, | key: HgPathBuf, | ||||
| value: HgPathBuf, | value: HgPathBuf, | ||||
| ) -> Result<Option<HgPathBuf>, DirstateV2ParseError> { | ) -> Result<Option<HgPathBuf>, DirstateV2ParseError> { | ||||
| let node = Self::get_or_insert_node( | let node = Self::get_or_insert_node( | ||||
| self.on_disk, | |||||
| &mut self.root, | &mut self.root, | ||||
| &key, | &key, | ||||
| WithBasename::to_cow_owned, | WithBasename::to_cow_owned, | ||||
| |_ancestor| {}, | |_ancestor| {}, | ||||
| )?; | )?; | ||||
| if node.copy_source.is_none() { | if node.copy_source.is_none() { | ||||
| self.nodes_with_copy_source_count += 1 | self.nodes_with_copy_source_count += 1 | ||||
| } | } | ||||
| Ok(if let Some(node) = self.get_node(key)? { | Ok(if let Some(node) = self.get_node(key)? { | ||||
| node.entry()? | node.entry()? | ||||
| } else { | } else { | ||||
| None | None | ||||
| }) | }) | ||||
| } | } | ||||
| fn iter(&self) -> StateMapIter<'_> { | fn iter(&self) -> StateMapIter<'_> { | ||||
| Box::new(filter_map_results(self.iter_nodes(), |node| { | Box::new(filter_map_results(self.iter_nodes(), move |node| { | ||||
| Ok(if let Some(entry) = node.entry()? { | Ok(if let Some(entry) = node.entry()? { | ||||
| Some((node.full_path()?, entry)) | Some((node.full_path(self.on_disk)?, entry)) | ||||
| } else { | } else { | ||||
| None | None | ||||
| }) | }) | ||||
| })) | })) | ||||
| } | } | ||||
| } | } | ||||
| + std::mem::size_of::<Node>() | + std::mem::size_of::<Node>() | ||||
| * dirstate_map.nodes_with_entry_count as usize; | * dirstate_map.nodes_with_entry_count as usize; | ||||
| let mut out = Vec::with_capacity(size_guess); | let mut out = Vec::with_capacity(size_guess); | ||||
| // Keep space for the header. We’ll fill it out at the end when we know the | // Keep space for the header. We’ll fill it out at the end when we know the | ||||
| // actual offset for the root nodes. | // actual offset for the root nodes. | ||||
| out.resize(header_len, 0_u8); | out.resize(header_len, 0_u8); | ||||
| let root = write_nodes(dirstate_map.root.as_ref(), &mut out)?; | let root = | ||||
| write_nodes(dirstate_map, dirstate_map.root.as_ref(), &mut out)?; | |||||
| let header = Header { | let header = Header { | ||||
| marker: *V2_FORMAT_MARKER, | marker: *V2_FORMAT_MARKER, | ||||
| parents: parents, | parents: parents, | ||||
| root, | root, | ||||
| nodes_with_entry_count: dirstate_map.nodes_with_entry_count.into(), | nodes_with_entry_count: dirstate_map.nodes_with_entry_count.into(), | ||||
| nodes_with_copy_source_count: dirstate_map | nodes_with_copy_source_count: dirstate_map | ||||
| .nodes_with_copy_source_count | .nodes_with_copy_source_count | ||||
| .into(), | .into(), | ||||
| }; | }; | ||||
| out[..header_len].copy_from_slice(header.as_bytes()); | out[..header_len].copy_from_slice(header.as_bytes()); | ||||
| Ok(out) | Ok(out) | ||||
| } | } | ||||
| fn write_nodes( | fn write_nodes( | ||||
| dirstate_map: &DirstateMap, | |||||
| nodes: dirstate_map::ChildNodesRef, | nodes: dirstate_map::ChildNodesRef, | ||||
| out: &mut Vec<u8>, | out: &mut Vec<u8>, | ||||
| ) -> Result<ChildNodes, DirstateError> { | ) -> Result<ChildNodes, DirstateError> { | ||||
| // `dirstate_map::ChildNodes` is a `HashMap` with undefined iteration | // `dirstate_map::ChildNodes` is a `HashMap` with undefined iteration | ||||
| // order. Sort to enable binary search in the written file. | // order. Sort to enable binary search in the written file. | ||||
| let nodes = nodes.sorted(); | let nodes = nodes.sorted(); | ||||
| // First accumulate serialized nodes in a `Vec` | // First accumulate serialized nodes in a `Vec` | ||||
| let mut on_disk_nodes = Vec::with_capacity(nodes.len()); | let mut on_disk_nodes = Vec::with_capacity(nodes.len()); | ||||
| for node in nodes { | for node in nodes { | ||||
| let children = write_nodes(node.children()?, out)?; | let children = node.children(dirstate_map.on_disk)?; | ||||
| let full_path = write_slice::<u8>(node.full_path()?.as_bytes(), out); | let children = write_nodes(dirstate_map, children, out)?; | ||||
| let copy_source = if let Some(source) = node.copy_source()? { | let full_path = node.full_path(dirstate_map.on_disk)?; | ||||
| let full_path = write_slice::<u8>(full_path.as_bytes(), out); | |||||
| let copy_source = | |||||
| if let Some(source) = node.copy_source(dirstate_map.on_disk)? { | |||||
| write_slice::<u8>(source.as_bytes(), out) | write_slice::<u8>(source.as_bytes(), out) | ||||
| } else { | } else { | ||||
| Slice { | Slice { | ||||
| start: 0.into(), | start: 0.into(), | ||||
| len: 0.into(), | len: 0.into(), | ||||
| } | } | ||||
| }; | }; | ||||
| on_disk_nodes.push(match node { | on_disk_nodes.push(match node { | ||||
| NodeRef::InMemory(path, node) => Node { | NodeRef::InMemory(path, node) => Node { | ||||
| children, | children, | ||||
| copy_source, | copy_source, | ||||
| full_path, | full_path, | ||||
| base_name_start: u32::try_from(path.base_name_start()) | base_name_start: u32::try_from(path.base_name_start()) | ||||
| // Could only panic for paths over 4 GiB | // Could only panic for paths over 4 GiB | ||||
| .expect("dirstate-v2 offset overflow") | .expect("dirstate-v2 offset overflow") | ||||
| /// | /// | ||||
| /// This algorithm is based on traversing the filesystem tree (`fs` in function | /// This algorithm is based on traversing the filesystem tree (`fs` in function | ||||
| /// and variable names) and dirstate tree at the same time. The core of this | /// and variable names) and dirstate tree at the same time. The core of this | ||||
| /// traversal is the recursive `traverse_fs_directory_and_dirstate` function | /// traversal is the recursive `traverse_fs_directory_and_dirstate` function | ||||
| /// and its use of `itertools::merge_join_by`. When reaching a path that only | /// and its use of `itertools::merge_join_by`. When reaching a path that only | ||||
| /// exists in one of the two trees, depending on information requested by | /// exists in one of the two trees, depending on information requested by | ||||
| /// `options` we may need to traverse the remaining subtree. | /// `options` we may need to traverse the remaining subtree. | ||||
| #[timed] | #[timed] | ||||
| pub fn status<'tree>( | pub fn status<'tree, 'on_disk: 'tree>( | ||||
| dmap: &'tree mut DirstateMap, | dmap: &'tree mut DirstateMap<'on_disk>, | ||||
| matcher: &(dyn Matcher + Sync), | matcher: &(dyn Matcher + Sync), | ||||
| root_dir: PathBuf, | root_dir: PathBuf, | ||||
| ignore_files: Vec<PathBuf>, | ignore_files: Vec<PathBuf>, | ||||
| options: StatusOptions, | options: StatusOptions, | ||||
| ) -> Result<(DirstateStatus<'tree>, Vec<PatternFileWarning>), StatusError> { | ) -> Result<(DirstateStatus<'tree>, Vec<PatternFileWarning>), StatusError> { | ||||
| let (ignore_fn, warnings): (IgnoreFnType, _) = | let (ignore_fn, warnings): (IgnoreFnType, _) = | ||||
| if options.list_ignored || options.list_unknown { | if options.list_ignored || options.list_unknown { | ||||
| get_ignore_function(ignore_files, &root_dir)? | get_ignore_function(ignore_files, &root_dir)? | ||||
| } else { | } else { | ||||
| (Box::new(|&_| true), vec![]) | (Box::new(|&_| true), vec![]) | ||||
| }; | }; | ||||
| let common = StatusCommon { | let common = StatusCommon { | ||||
| dmap, | |||||
| options, | options, | ||||
| matcher, | matcher, | ||||
| ignore_fn, | ignore_fn, | ||||
| outcome: Mutex::new(DirstateStatus::default()), | outcome: Mutex::new(DirstateStatus::default()), | ||||
| }; | }; | ||||
| let is_at_repo_root = true; | let is_at_repo_root = true; | ||||
| let hg_path = HgPath::new(""); | let hg_path = HgPath::new(""); | ||||
| let has_ignored_ancestor = false; | let has_ignored_ancestor = false; | ||||
| common.traverse_fs_directory_and_dirstate( | common.traverse_fs_directory_and_dirstate( | ||||
| has_ignored_ancestor, | has_ignored_ancestor, | ||||
| dmap.root.as_ref(), | dmap.root.as_ref(), | ||||
| hg_path, | hg_path, | ||||
| &root_dir, | &root_dir, | ||||
| is_at_repo_root, | is_at_repo_root, | ||||
| )?; | )?; | ||||
| Ok((common.outcome.into_inner().unwrap(), warnings)) | Ok((common.outcome.into_inner().unwrap(), warnings)) | ||||
| } | } | ||||
| /// Bag of random things needed by various parts of the algorithm. Reduces the | /// Bag of random things needed by various parts of the algorithm. Reduces the | ||||
| /// number of parameters passed to functions. | /// number of parameters passed to functions. | ||||
| struct StatusCommon<'tree, 'a> { | struct StatusCommon<'tree, 'a, 'on_disk: 'tree> { | ||||
| dmap: &'tree DirstateMap<'on_disk>, | |||||
| options: StatusOptions, | options: StatusOptions, | ||||
| matcher: &'a (dyn Matcher + Sync), | matcher: &'a (dyn Matcher + Sync), | ||||
| ignore_fn: IgnoreFnType<'a>, | ignore_fn: IgnoreFnType<'a>, | ||||
| outcome: Mutex<DirstateStatus<'tree>>, | outcome: Mutex<DirstateStatus<'tree>>, | ||||
| } | } | ||||
| impl<'tree, 'a> StatusCommon<'tree, 'a> { | impl<'tree, 'a> StatusCommon<'tree, 'a, '_> { | ||||
| fn read_dir( | fn read_dir( | ||||
| &self, | &self, | ||||
| hg_path: &HgPath, | hg_path: &HgPath, | ||||
| fs_path: &Path, | fs_path: &Path, | ||||
| is_at_repo_root: bool, | is_at_repo_root: bool, | ||||
| ) -> Result<Vec<DirEntry>, ()> { | ) -> Result<Vec<DirEntry>, ()> { | ||||
| DirEntry::read_dir(fs_path, is_at_repo_root).map_err(|error| { | DirEntry::read_dir(fs_path, is_at_repo_root).map_err(|error| { | ||||
| let errno = error.raw_os_error().expect("expected real OS error"); | let errno = error.raw_os_error().expect("expected real OS error"); | ||||
| let dirstate_nodes = dirstate_nodes.sorted(); | let dirstate_nodes = dirstate_nodes.sorted(); | ||||
| // `sort_unstable_by_key` doesn’t allow keys borrowing from the value: | // `sort_unstable_by_key` doesn’t allow keys borrowing from the value: | ||||
| // https://github.com/rust-lang/rust/issues/34162 | // https://github.com/rust-lang/rust/issues/34162 | ||||
| fs_entries.sort_unstable_by(|e1, e2| e1.base_name.cmp(&e2.base_name)); | fs_entries.sort_unstable_by(|e1, e2| e1.base_name.cmp(&e2.base_name)); | ||||
| // Propagate here any error that would happen inside the comparison | // Propagate here any error that would happen inside the comparison | ||||
| // callback below | // callback below | ||||
| for dirstate_node in &dirstate_nodes { | for dirstate_node in &dirstate_nodes { | ||||
| dirstate_node.base_name()?; | dirstate_node.base_name(self.dmap.on_disk)?; | ||||
| } | } | ||||
| itertools::merge_join_by( | itertools::merge_join_by( | ||||
| dirstate_nodes, | dirstate_nodes, | ||||
| &fs_entries, | &fs_entries, | ||||
| |dirstate_node, fs_entry| { | |dirstate_node, fs_entry| { | ||||
| // This `unwrap` never panics because we already propagated | // This `unwrap` never panics because we already propagated | ||||
| // those errors above | // those errors above | ||||
| dirstate_node.base_name().unwrap().cmp(&fs_entry.base_name) | dirstate_node | ||||
| .base_name(self.dmap.on_disk) | |||||
| .unwrap() | |||||
| .cmp(&fs_entry.base_name) | |||||
| }, | }, | ||||
| ) | ) | ||||
| .par_bridge() | .par_bridge() | ||||
| .map(|pair| { | .map(|pair| { | ||||
| use itertools::EitherOrBoth::*; | use itertools::EitherOrBoth::*; | ||||
| match pair { | match pair { | ||||
| Both(dirstate_node, fs_entry) => self | Both(dirstate_node, fs_entry) => self | ||||
| .traverse_fs_and_dirstate( | .traverse_fs_and_dirstate( | ||||
| } | } | ||||
| fn traverse_fs_and_dirstate( | fn traverse_fs_and_dirstate( | ||||
| &self, | &self, | ||||
| fs_entry: &DirEntry, | fs_entry: &DirEntry, | ||||
| dirstate_node: NodeRef<'tree, '_>, | dirstate_node: NodeRef<'tree, '_>, | ||||
| has_ignored_ancestor: bool, | has_ignored_ancestor: bool, | ||||
| ) -> Result<(), DirstateV2ParseError> { | ) -> Result<(), DirstateV2ParseError> { | ||||
| let hg_path = dirstate_node.full_path()?; | let hg_path = dirstate_node.full_path(self.dmap.on_disk)?; | ||||
| let file_type = fs_entry.metadata.file_type(); | let file_type = fs_entry.metadata.file_type(); | ||||
| let file_or_symlink = file_type.is_file() || file_type.is_symlink(); | let file_or_symlink = file_type.is_file() || file_type.is_symlink(); | ||||
| if !file_or_symlink { | if !file_or_symlink { | ||||
| // If we previously had a file here, it was removed (with | // If we previously had a file here, it was removed (with | ||||
| // `hg rm` or similar) or deleted before it could be | // `hg rm` or similar) or deleted before it could be | ||||
| // replaced by a directory or something else. | // replaced by a directory or something else. | ||||
| self.mark_removed_or_deleted_if_file( | self.mark_removed_or_deleted_if_file( | ||||
| hg_path, | hg_path, | ||||
| dirstate_node.state()?, | dirstate_node.state()?, | ||||
| ); | ); | ||||
| } | } | ||||
| if file_type.is_dir() { | if file_type.is_dir() { | ||||
| if self.options.collect_traversed_dirs { | if self.options.collect_traversed_dirs { | ||||
| self.outcome.lock().unwrap().traversed.push(hg_path.into()) | self.outcome.lock().unwrap().traversed.push(hg_path.into()) | ||||
| } | } | ||||
| let is_ignored = has_ignored_ancestor || (self.ignore_fn)(hg_path); | let is_ignored = has_ignored_ancestor || (self.ignore_fn)(hg_path); | ||||
| let is_at_repo_root = false; | let is_at_repo_root = false; | ||||
| self.traverse_fs_directory_and_dirstate( | self.traverse_fs_directory_and_dirstate( | ||||
| is_ignored, | is_ignored, | ||||
| dirstate_node.children()?, | dirstate_node.children(self.dmap.on_disk)?, | ||||
| hg_path, | hg_path, | ||||
| &fs_entry.full_path, | &fs_entry.full_path, | ||||
| is_at_repo_root, | is_at_repo_root, | ||||
| )? | )? | ||||
| } else { | } else { | ||||
| if file_or_symlink && self.matcher.matches(hg_path) { | if file_or_symlink && self.matcher.matches(hg_path) { | ||||
| let full_path = Cow::from(hg_path); | let full_path = Cow::from(hg_path); | ||||
| if let Some(state) = dirstate_node.state()? { | if let Some(state) = dirstate_node.state()? { | ||||
| // node, but the filesystem has a file | // node, but the filesystem has a file | ||||
| self.mark_unknown_or_ignored( | self.mark_unknown_or_ignored( | ||||
| has_ignored_ancestor, | has_ignored_ancestor, | ||||
| full_path, | full_path, | ||||
| ) | ) | ||||
| } | } | ||||
| } | } | ||||
| for child_node in dirstate_node.children()?.iter() { | for child_node in dirstate_node.children(self.dmap.on_disk)?.iter() | ||||
| { | |||||
| self.traverse_dirstate_only(child_node)? | self.traverse_dirstate_only(child_node)? | ||||
| } | } | ||||
| } | } | ||||
| Ok(()) | Ok(()) | ||||
| } | } | ||||
| /// A file with `EntryState::Normal` in the dirstate was found in the | /// A file with `EntryState::Normal` in the dirstate was found in the | ||||
| /// filesystem | /// filesystem | ||||
| fn handle_normal_file( | fn handle_normal_file( | ||||
| &self, | &self, | ||||
| dirstate_node: &NodeRef<'tree, '_>, | dirstate_node: &NodeRef<'tree, '_>, | ||||
| fs_entry: &DirEntry, | fs_entry: &DirEntry, | ||||
| ) -> Result<(), DirstateV2ParseError> { | ) -> Result<(), DirstateV2ParseError> { | ||||
| // Keep the low 31 bits | // Keep the low 31 bits | ||||
| fn truncate_u64(value: u64) -> i32 { | fn truncate_u64(value: u64) -> i32 { | ||||
| (value & 0x7FFF_FFFF) as i32 | (value & 0x7FFF_FFFF) as i32 | ||||
| } | } | ||||
| fn truncate_i64(value: i64) -> i32 { | fn truncate_i64(value: i64) -> i32 { | ||||
| (value & 0x7FFF_FFFF) as i32 | (value & 0x7FFF_FFFF) as i32 | ||||
| } | } | ||||
| let entry = dirstate_node | let entry = dirstate_node | ||||
| .entry()? | .entry()? | ||||
| .expect("handle_normal_file called with entry-less node"); | .expect("handle_normal_file called with entry-less node"); | ||||
| let full_path = Cow::from(dirstate_node.full_path()?); | let full_path = Cow::from(dirstate_node.full_path(self.dmap.on_disk)?); | ||||
| let mode_changed = || { | let mode_changed = || { | ||||
| self.options.check_exec && entry.mode_changed(&fs_entry.metadata) | self.options.check_exec && entry.mode_changed(&fs_entry.metadata) | ||||
| }; | }; | ||||
| let size_changed = entry.size != truncate_u64(fs_entry.metadata.len()); | let size_changed = entry.size != truncate_u64(fs_entry.metadata.len()); | ||||
| if entry.size >= 0 | if entry.size >= 0 | ||||
| && size_changed | && size_changed | ||||
| && fs_entry.metadata.file_type().is_symlink() | && fs_entry.metadata.file_type().is_symlink() | ||||
| { | { | ||||
| } | } | ||||
| /// A node in the dirstate tree has no corresponding filesystem entry | /// A node in the dirstate tree has no corresponding filesystem entry | ||||
| fn traverse_dirstate_only( | fn traverse_dirstate_only( | ||||
| &self, | &self, | ||||
| dirstate_node: NodeRef<'tree, '_>, | dirstate_node: NodeRef<'tree, '_>, | ||||
| ) -> Result<(), DirstateV2ParseError> { | ) -> Result<(), DirstateV2ParseError> { | ||||
| self.mark_removed_or_deleted_if_file( | self.mark_removed_or_deleted_if_file( | ||||
| dirstate_node.full_path()?, | dirstate_node.full_path(self.dmap.on_disk)?, | ||||
| dirstate_node.state()?, | dirstate_node.state()?, | ||||
| ); | ); | ||||
| dirstate_node | dirstate_node | ||||
| .children()? | .children(self.dmap.on_disk)? | ||||
| .par_iter() | .par_iter() | ||||
| .map(|child_node| self.traverse_dirstate_only(child_node)) | .map(|child_node| self.traverse_dirstate_only(child_node)) | ||||
| .collect() | .collect() | ||||
| } | } | ||||
| /// A node in the dirstate tree has no corresponding *file* on the | /// A node in the dirstate tree has no corresponding *file* on the | ||||
| /// filesystem | /// filesystem | ||||
| /// | /// | ||||