rust-files: also return filenode and flags when listing a revision's files

This is going to be useful when implementing parts of `update` and makes it
so we don't have to fetch the manifest and each entry twice.

rust/hg-core/src/operations/list_tracked_files.rs

@@ -1,45 +1,54 b''
 // list_tracked_files.rs
 //
 // Copyright 2020 Antoine Cezar <[e-mail]>
 //
 // This software may be used and distributed according to the terms of the
 // GNU General Public License version 2 or any later version.
 
+use std::num::NonZeroU8;
+
 use crate::errors::HgError;
 use crate::matchers::Matcher;
 use crate::repo::Repo;
 use crate::revlog::manifest::Manifest;
 use crate::revlog::RevlogError;
 use crate::utils::filter_map_results;
 use crate::utils::hg_path::HgPath;
+use crate::Node;
 
 /// List files under Mercurial control at a given revision.
 pub fn list_rev_tracked_files(
     repo: &Repo,
     revset: &str,
     narrow_matcher: Box<dyn Matcher>,
 ) -> Result<FilesForRev, RevlogError> {
     let rev = crate::revset::resolve_single(revset, repo)?;
     Ok(FilesForRev {
         manifest: repo.manifest_for_rev(rev.into())?,
         narrow_matcher,
     })
 }
 
 pub struct FilesForRev {
     manifest: Manifest,
     narrow_matcher: Box<dyn Matcher>,
 }
 
+/// Like [`crate::revlog::manifest::ManifestEntry`], but with the `Node`
+/// already checked.
+pub type ExpandedManifestEntry<'a> = (&'a HgPath, Node, Option<NonZeroU8>);
+
 impl FilesForRev {
-    pub fn iter(&self) -> impl Iterator<Item = Result<&HgPath, HgError>> {
+    pub fn iter(
+        &self,
+    ) -> impl Iterator<Item = Result<ExpandedManifestEntry, HgError>> {
         filter_map_results(self.manifest.iter(), |entry| {
             let path = entry.path;
             Ok(if self.narrow_matcher.matches(path) {
-                Some(path)
+                Some((path, entry.node_id()?, entry.flags))
             } else {
                 None
             })
         })
     }
 }

rust/rhg/src/commands/files.rs

@@ -1,149 +1,157 b''
 use crate::error::CommandError;
 use crate::ui::{
     print_narrow_sparse_warnings, relative_paths, RelativePaths, Ui,
 };
 use crate::utils::path_utils::RelativizePaths;
 use clap::Arg;
 use hg::filepatterns::parse_pattern_args;
 use hg::matchers::IntersectionMatcher;
 use hg::narrow;
 use hg::operations::list_rev_tracked_files;
 use hg::repo::Repo;
 use hg::utils::files::get_bytes_from_os_str;
 use hg::utils::filter_map_results;
 use hg::utils::hg_path::HgPath;
 use rayon::prelude::*;
 
 pub const HELP_TEXT: &str = "
 List tracked files.
 
 Returns 0 on success.
 ";
 
 pub fn args() -> clap::Command {
     clap::command!("files")
         .arg(
             Arg::new("rev")
                 .help("search the repository as it is in REV")
                 .short('r')
                 .long("revision")
                 .value_name("REV"),
         )
         .arg(
             Arg::new("file")
                 .value_parser(clap::value_parser!(std::ffi::OsString))
                 .help("show only these files")
                 .action(clap::ArgAction::Append),
         )
         .about(HELP_TEXT)
 }
 
 pub fn run(invocation: &crate::CliInvocation) -> Result<(), CommandError> {
     let relative_paths = match relative_paths(invocation.config)? {
         RelativePaths::Legacy => true,
         RelativePaths::Bool(v) => v,
     };
 
     let args = invocation.subcommand_args;
     let rev = args.get_one::<String>("rev");
 
     let repo = invocation.repo?;
 
     // It seems better if this check is removed: this would correspond to
     // automatically enabling the extension if the repo requires it.
     // However we need this check to be in sync with vanilla hg so hg tests
     // pass.
     if repo.has_sparse()
         && invocation.config.get(b"extensions", b"sparse").is_none()
     {
         return Err(CommandError::unsupported(
             "repo is using sparse, but sparse extension is not enabled",
         ));
     }
 
     let (matcher, narrow_warnings) = narrow::matcher(repo)?;
     print_narrow_sparse_warnings(&narrow_warnings, &[], invocation.ui, repo)?;
     let matcher = match args.get_many::<std::ffi::OsString>("file") {
         None => matcher,
         Some(files) => {
             let patterns: Vec<Vec<u8>> = files
                 .filter(|s| !s.is_empty())
                 .map(get_bytes_from_os_str)
                 .collect();
             for file in &patterns {
                 if file.starts_with(b"set:") {
                     return Err(CommandError::unsupported("fileset"));
                 }
             }
             let cwd = hg::utils::current_dir()?;
             let root = repo.working_directory_path();
             let ignore_patterns = parse_pattern_args(patterns, &cwd, root)?;
             let files_matcher =
                 hg::matchers::PatternMatcher::new(ignore_patterns)?;
             Box::new(IntersectionMatcher::new(
                 Box::new(files_matcher),
                 matcher,
             ))
         }
     };
 
     if let Some(rev) = rev {
         let files = list_rev_tracked_files(repo, rev, matcher)
             .map_err(|e| (e, rev.as_ref()))?;
-        display_files(invocation.ui, repo, relative_paths, files.iter())
+        display_files(
+            invocation.ui,
+            repo,
+            relative_paths,
+            files.iter().map::<Result<_, CommandError>, _>(|f| {
+                let (f, _, _) = f?;
+                Ok(f)
+            }),
+        )
     } else {
         // The dirstate always reflects the sparse narrowspec.
         let dirstate = repo.dirstate_map()?;
         let files_res: Result<Vec<_>, _> =
             filter_map_results(dirstate.iter(), |(path, entry)| {
                 Ok(if entry.tracked() && matcher.matches(path) {
                     Some(path)
                 } else {
                     None
                 })
             })
             .collect();
 
         let mut files = files_res?;
         files.par_sort_unstable();
 
         display_files(
             invocation.ui,
             repo,
             relative_paths,
             files.into_iter().map::<Result<_, CommandError>, _>(Ok),
         )
     }
 }
 
 fn display_files<'a, E>(
     ui: &Ui,
     repo: &Repo,
     relative_paths: bool,
     files: impl IntoIterator<Item = Result<&'a HgPath, E>>,
 ) -> Result<(), CommandError>
 where
     CommandError: From<E>,
 {
     let mut stdout = ui.stdout_buffer();
     let mut any = false;
 
     let relativize = RelativizePaths::new(repo)?;
     for result in files {
         let path = result?;
         if relative_paths {
             stdout.write_all(&relativize.relativize(path))?;
         } else {
             stdout.write_all(path.as_bytes())?;
         }
         stdout.write_all(b"\n")?;
         any = true;
     }
 
     stdout.flush()?;
     if any {
         Ok(())
     } else {
         Err(CommandError::Unsuccessful)
     }
 }