Track the first manifest path as an implicit, fallback root

To allow a package to be unpacked outside of all root directories, such
as `/tmp/my-package` and allow a build to start from
`/tmp/my-package/sub/dir`, Cargo is allowed to traverse parent
directories until it finds its first manifest, and this then becomes a
fallback root directory that will stop Cargo from looking any higher for
a workspace (which could attempt to load `/tmp/Cargo.toml` that may not
be safe).

XXX: Instead of having a special case for the first manifest; maybe it could
be better to instead _always_ add the directory of a manifest as a root
directory if it's not a subdirectory of any existing root.

That would have a mostly-equivalent result to the current behaviour but
_might_ be simpler to document?

Author: rib

src/bin/cargo/commands/locate_project.rs

@@ -30,10 +30,12 @@ pub fn exec(gctx: &mut GlobalContext, args: &ArgMatches) -> CliResult {
     let workspace;
     let root = match WhatToFind::parse(args) {
         WhatToFind::CurrentManifest => {
+            tracing::trace!("locate-project::exec(): finding root manifest");
             root_manifest = args.root_manifest(gctx)?;
             &root_manifest
         }
         WhatToFind::Workspace => {
+            tracing::trace!("locate-project::exec(): finding workspace root manifest");
             workspace = args.workspace(gctx)?;
             workspace.root_manifest()
         }

src/cargo/util/context/mod.rs

@@ -202,6 +202,9 @@ pub struct GlobalContext {
     /// The full set of root directories that limit config file searching.
     /// Sorted by path length, longest first.
     sorted_roots: Vec<PathBuf>,
+    /// In case we are running outside of any user-configured root directory, we
+    /// add the directory of the first manifest as as root directory.
+    fallback_manifest_root: RefCell<Option<PathBuf>>,
     /// Directories to search for config files (invalidated if roots or cwd changes).
     config_search_route: RefCell<Option<SearchRoute>>,
     /// Directories to search for manifest files (invalidated if roots or starting point changes).
@@ -319,6 +322,7 @@ impl GlobalContext {
             shell: RefCell::new(shell),
             cwd,
             sorted_roots: Vec::new(),
+            fallback_manifest_root: RefCell::new(None),
             config_search_route: RefCell::new(None),
             manifest_search_route: RefCell::new(None),
             values: LazyCell::new(),
@@ -617,6 +621,24 @@ impl GlobalContext {
         Ok(())
     }
 
+    pub fn ensure_fallback_root<P: AsRef<Path>>(&self, path: P) {
+        let path = path
+            .as_ref()
+            .canonicalize()
+            .expect("failed to canonicalize path");
+        if self.fallback_manifest_root.borrow_mut().is_none() {
+            tracing::debug!("Setting fallback manifest root to {:?}", path);
+            *self.fallback_manifest_root.borrow_mut() = Some(path);
+            *self.config_search_route.borrow_mut() = None;
+            *self.manifest_search_route.borrow_mut() = None;
+        } else {
+            tracing::debug!(
+                "Fallback manifest root already set to {:?}, not changing",
+                self.fallback_manifest_root.borrow()
+            );
+        }
+    }
+
     fn find_nearest_root<P: AsRef<Path>>(
         &self,
         start: P,
@@ -626,7 +648,10 @@ impl GlobalContext {
             .canonicalize()
             .context("couldn't canonicalize path")?;
 
-        tracing::debug!("Searching sorted roots for start {:?}", self.sorted_roots);
+        tracing::debug!(
+            "Searching sorted roots for closest ancestor {:?}",
+            self.sorted_roots
+        );
         let root = self
             .sorted_roots
             .iter()
@@ -636,6 +661,9 @@ impl GlobalContext {
         if let Some(root) = root {
             tracing::debug!("Found candidate root {:?}", root);
             Ok(Some((start, root)))
+        } else if let Some(fallback_root) = self.fallback_manifest_root.borrow().as_ref() {
+            tracing::debug!("Using manifest path as fallback root");
+            Ok(Some((start, fallback_root.clone())))
         } else {
             tracing::debug!("No candidate root found for start {:?}", start);
             Ok(None)

src/cargo/util/important_paths.rs

@@ -14,6 +14,12 @@ pub fn find_root_manifest_for_wd(gctx: &GlobalContext, cwd: &Path) -> CargoResul
     for current in paths::ancestors(&search_route.start, search_route.root.as_deref()) {
         let manifest = current.join(valid_cargo_toml_file_name);
         if manifest.exists() {
+            // In case we are running outside of any root directory, the directory for the
+            // first root manifest we find will become the fallback root. This is part of
+            // a safety trade-off that allows us to traverse unknown ancestors to find
+            // a package, but limits the risk of continuing to traverse and load manifests
+            // that we might not own (such as `/tmp/Cargo.toml`)
+            gctx.ensure_fallback_root(current);
             return Ok(manifest);
         }
         if current.join(invalid_cargo_toml_file_name).exists() {