refactor: cache cwd at startup instead of per-entry resolution

Instead of calling current_dir() for every entry when --full-path is
set, cache it once in Config at startup. This eliminates the need for
FatalError handling and makes path resolution infallible during the
walk. If the cwd can't be retrieved, fd now fails early with a clear
error message.

Author: Xavrir

src/config.rs

@@ -15,9 +15,9 @@ pub struct Config {
     /// Whether the search is case-sensitive or case-insensitive.
     pub case_sensitive: bool,
 
-    /// Whether to search within the full file path or just the base name (filename or directory
-    /// name).
-    pub search_full_path: bool,
+    /// Cached current working directory for absolute path construction.
+    /// Populated when `--full-path` is set; `None` means search by filename only.
+    pub cwd: Option<PathBuf>,
 
     /// Whether to ignore hidden files and directories (or not).
     pub ignore_hidden: bool,

src/exec/job.rs

@@ -28,12 +28,6 @@ pub fn job(
                 }
                 continue;
             }
-            WorkerResult::FatalError(err) => {
-                if config.show_filesystem_errors {
-                    print_error(err.to_string());
-                }
-                return ExitCode::GeneralError;
-            }
         };
 
         // Generate a command, execute it and store its exit code.
@@ -54,28 +48,17 @@ pub fn batch(
     cmd: &CommandSet,
     config: &Config,
 ) -> ExitCode {
-    let mut paths = Vec::new();
-
-    for worker_result in results {
-        match worker_result {
-            WorkerResult::Entry(dir_entry) => paths.push(dir_entry.into_stripped_path(config)),
+    let paths = results
+        .into_iter()
+        .filter_map(|worker_result| match worker_result {
+            WorkerResult::Entry(dir_entry) => Some(dir_entry.into_stripped_path(config)),
             WorkerResult::Error(err) => {
                 if config.show_filesystem_errors {
                     print_error(err.to_string());
                 }
+                None
             }
-            WorkerResult::FatalError(err) => {
-                if config.show_filesystem_errors {
-                    print_error(err.to_string());
-                }
-                return ExitCode::GeneralError;
-            }
-        }
-    }
+        });
 
-    cmd.execute_batch(
-        paths.into_iter(),
-        config.batch_size,
-        config.path_separator.as_deref(),
-    )
+    cmd.execute_batch(paths, config.batch_size, config.path_separator.as_deref())
 }

src/filesystem.rs

@@ -20,6 +20,17 @@ pub fn path_absolute_form(path: &Path) -> io::Result<PathBuf> {
     env::current_dir().map(|path_buf| path_buf.join(path))
 }
 
+/// Construct an absolute path from a potentially relative path and a
+/// pre-resolved working directory. Unlike `path_absolute_form`, this
+/// does not call `env::current_dir()` and cannot fail.
+pub fn make_absolute(path: &Path, cwd: &Path) -> PathBuf {
+    if path.is_absolute() {
+        return path.to_path_buf();
+    }
+    let path = path.strip_prefix(".").unwrap_or(path);
+    cwd.join(path)
+}
+
 pub fn absolute_path(path: &Path) -> io::Result<PathBuf> {
     let path_buf = path_absolute_form(path)?;
 
@@ -153,4 +164,40 @@ mod tests {
             Path::new("foo/bar/baz")
         );
     }
+
+    #[test]
+    fn make_absolute_with_relative_path() {
+        use super::make_absolute;
+        use std::path::PathBuf;
+
+        let cwd = Path::new("/home/user");
+        assert_eq!(
+            make_absolute(Path::new("foo/bar"), cwd),
+            PathBuf::from("/home/user/foo/bar")
+        );
+    }
+
+    #[test]
+    fn make_absolute_strips_dot_prefix() {
+        use super::make_absolute;
+        use std::path::PathBuf;
+
+        let cwd = Path::new("/home/user");
+        assert_eq!(
+            make_absolute(Path::new("./foo/bar"), cwd),
+            PathBuf::from("/home/user/foo/bar")
+        );
+    }
+
+    #[test]
+    fn make_absolute_with_absolute_path() {
+        use super::make_absolute;
+        use std::path::PathBuf;
+
+        let cwd = Path::new("/home/user");
+        assert_eq!(
+            make_absolute(Path::new("/absolute/path"), cwd),
+            PathBuf::from("/absolute/path")
+        );
+    }
 }

src/main.rs

@@ -245,9 +245,18 @@ fn construct_config(mut opts: Opts, pattern_regexps: &[String]) -> Result<Config
     let command = extract_command(&mut opts, colored_output)?;
     let has_command = command.is_some();
 
+    let cwd = if opts.full_path {
+        Some(env::current_dir().context(
+            "Could not determine current directory. \
+             This is required for --full-path.",
+        )?)
+    } else {
+        None
+    };
+
     Ok(Config {
         case_sensitive,
-        search_full_path: opts.full_path,
+        cwd,
         ignore_hidden: !(opts.hidden || opts.rg_alias_ignore()),
         read_fdignore: !(opts.no_ignore || opts.rg_alias_ignore()),
         read_vcsignore: !(opts.no_ignore || opts.rg_alias_ignore() || opts.no_ignore_vcs),

src/walk.rs

@@ -42,7 +42,6 @@ pub enum WorkerResult {
     // to box the Entry variant
     Entry(DirEntry),
     Error(ignore::Error),
-    FatalError(ignore::Error),
 }
 
 /// A batch of WorkerResults to send over a channel.
@@ -230,12 +229,6 @@ impl<'a, W: Write> ReceiverBuffer<'a, W> {
                                 print_error(err.to_string());
                             }
                         }
-                        WorkerResult::FatalError(err) => {
-                            if self.config.show_filesystem_errors {
-                                print_error(err.to_string());
-                            }
-                            return Err(ExitCode::GeneralError);
-                        }
                     }
                 }
 
@@ -531,20 +524,7 @@ impl WorkerState {
                 // Check the name first, since it doesn't require metadata
                 let entry_path = entry.path();
 
-                let search_str = match search_str_for_entry(entry_path, config.search_full_path) {
-                    Ok(search_str) => search_str,
-                    Err(err) => {
-                        let error = ignore::Error::WithPath {
-                            path: entry_path.to_path_buf(),
-                            err: Box::new(ignore::Error::Io(err)),
-                        };
-
-                        return match tx.send(WorkerResult::FatalError(error)) {
-                            Ok(_) => WalkState::Quit,
-                            Err(_) => WalkState::Quit,
-                        };
-                    }
-                };
+                let search_str = search_str_for_entry(entry_path, config.cwd.as_deref());
 
                 if !patterns
                     .iter()
@@ -685,14 +665,14 @@ impl WorkerState {
 
 fn search_str_for_entry<'a>(
     entry_path: &'a std::path::Path,
-    search_full_path: bool,
-) -> io::Result<Cow<'a, OsStr>> {
-    if search_full_path {
-        let path_abs_buf = filesystem::path_absolute_form(entry_path)?;
-        Ok(Cow::Owned(path_abs_buf.as_os_str().to_os_string()))
+    cwd: Option<&std::path::Path>,
+) -> Cow<'a, OsStr> {
+    if let Some(cwd) = cwd {
+        let abs_path = filesystem::make_absolute(entry_path, cwd);
+        Cow::Owned(abs_path.as_os_str().to_os_string())
     } else {
         match entry_path.file_name() {
-            Some(filename) => Ok(Cow::Borrowed(filename)),
+            Some(filename) => Cow::Borrowed(filename),
             None => unreachable!(
                 "Encountered file system entry without a file name. This should only \
                  happen for paths like 'foo/bar/..' or '/' which are not supposed to \
@@ -710,29 +690,3 @@ fn search_str_for_entry<'a>(
 pub fn scan(paths: &[PathBuf], patterns: Vec<Regex>, config: Config) -> Result<ExitCode> {
     WorkerState::new(patterns, config).scan(paths)
 }
-
-#[cfg(test)]
-mod tests {
-    use super::search_str_for_entry;
-    use std::env;
-    use std::fs;
-    use std::path::Path;
-
-    #[test]
-    #[cfg(all(not(windows), not(target_os = "illumos")))]
-    fn full_path_search_returns_error_for_invalid_cwd() {
-        let original_dir = env::current_dir().unwrap();
-        let temp_dir = tempfile::tempdir().unwrap();
-        let cwd = temp_dir.path().join("cwd");
-
-        fs::create_dir(&cwd).unwrap();
-        env::set_current_dir(&cwd).unwrap();
-        fs::remove_dir(&cwd).unwrap();
-
-        let result = search_str_for_entry(Path::new("relative/path"), true);
-
-        env::set_current_dir(original_dir).unwrap();
-
-        assert!(result.is_err());
-    }
-}