debugstate: Always call dirstatemap.debug_iter()

… passing it a new `all` argument for the `--all` CLI option,
instead of conditionally calling `.debug_iter()` or `.items()`

This prepares for the next commit.

Differential Revision: https://phab.mercurial-scm.org/D11462

mercurial/debugcommands.py

@@ -968,10 +968,7 b' def debugstate(ui, repo, **opts):'
         )  # sort by mtime, then by filename
     else:
         keyfunc = None  # sort by filename
-    if opts['all']:
-        entries = list(repo.dirstate._map.debug_iter())
-    else:
-        entries = list(pycompat.iteritems(repo.dirstate))
+    entries = list(repo.dirstate._map.debug_iter(all=opts['all']))
     entries.sort(key=keyfunc)
     for file_, ent in entries:
         if ent.v1_mtime() == -1:

mercurial/dirstatemap.py

@@ -118,7 +118,11 b' class dirstatemap(object):'
     # forward for python2,3 compat
     iteritems = items
 
-    debug_iter = items
+    def debug_iter(self, all):
+        """
+        `all` is unused when Rust is not enabled
+        """
+        return self.item()
 
     def __len__(self):
         return len(self._map)
@@ -700,8 +704,8 b' if rustmod is not None:'
         def copymap(self):
             return self._rustmap.copymap()
 
-        def debug_iter(self):
-            return self._rustmap.debug_iter()
+        def debug_iter(self, all):
+            return self._rustmap.debug_iter(all)
 
         def preload(self):
             self._rustmap

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

@@ -1289,6 +1289,7 b" impl<'on_disk> super::dispatch::Dirstate"
 
     fn debug_iter(
         &self,
+        all: bool,
     ) -> Box<
         dyn Iterator<
                 Item = Result<
@@ -1298,16 +1299,17 b" impl<'on_disk> super::dispatch::Dirstate"
             > + Send
             + '_,
     > {
-        Box::new(self.iter_nodes().map(move |node| {
-            let node = node?;
+        Box::new(filter_map_results(self.iter_nodes(), move |node| {
             let debug_tuple = if let Some(entry) = node.entry()? {
                 entry.debug_tuple()
+            } else if !all {
+                return Ok(None);
             } else if let Some(mtime) = node.cached_directory_mtime() {
                 (b' ', 0, -1, mtime.seconds() as i32)
             } else {
                 (b' ', 0, -1, -1)
             };
-            Ok((node.full_path(self.on_disk)?, debug_tuple))
+            Ok(Some((node.full_path(self.on_disk)?, debug_tuple)))
         }))
     }
 }

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

@@ -290,13 +290,15 b' pub trait DirstateMapMethods {'
     /// node stored in this dirstate map, for the purpose of the `hg
     /// debugdirstate` command.
     ///
-    /// For nodes that don’t have an entry, `state` is the ASCII space.
+    /// If `all` is true, include  nodes that don’t have an entry.
+    /// For such nodes `state` is the ASCII space.
     /// An `mtime` may still be present. It is used to optimize `status`.
     ///
     /// Because parse errors can happen during iteration, the iterated items
     /// are `Result`s.
     fn debug_iter(
         &self,
+        all: bool,
     ) -> Box<
         dyn Iterator<
                 Item = Result<
@@ -538,6 +540,7 b' impl DirstateMapMethods for DirstateMap '
 
     fn debug_iter(
         &self,
+        all: bool,
     ) -> Box<
         dyn Iterator<
                 Item = Result<
@@ -547,6 +550,9 b' impl DirstateMapMethods for DirstateMap '
             > + Send
             + '_,
     > {
+        // Not used for the flat (not tree-based) DirstateMap
+        let _ = all;
+
         Box::new(
             (&**self)
                 .iter()

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

@@ -226,6 +226,7 b' impl DirstateMapMethods for OwningDirsta'
 
     fn debug_iter(
         &self,
+        all: bool,
     ) -> Box<
         dyn Iterator<
                 Item = Result<
@@ -235,6 +236,6 b' impl DirstateMapMethods for OwningDirsta'
             > + Send
             + '_,
     > {
-        self.get().debug_iter()
+        self.get().debug_iter(all)
     }
 }

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

@@ -606,9 +606,9 b' py_class!(pub class DirstateMap |py| {'
         Ok(dirs)
     }
 
-    def debug_iter(&self) -> PyResult<PyList> {
+    def debug_iter(&self, all: bool) -> PyResult<PyList> {
         let dirs = PyList::new(py, &[]);
-        for item in self.inner(py).borrow().debug_iter() {
+        for item in self.inner(py).borrow().debug_iter(all) {
             let (path, (state, mode, size, mtime)) =
                 item.map_err(|e| v2_error(py, e))?;
             let path = PyBytes::new(py, path.as_bytes());