feat: add new lockfile-path for metadata

- Also add necessary tests for the new flag

Author: ifropc

src/bin/cargo/commands/metadata.rs

@@ -1,6 +1,7 @@
-use crate::command_prelude::*;
 use cargo::ops::{self, OutputMetadataOptions};
 
+use crate::command_prelude::*;
+
 pub fn cli() -> Command {
     subcommand("metadata")
         .about(
@@ -26,6 +27,7 @@ pub fn cli() -> Command {
         .arg_silent_suggestion()
         .arg_features()
         .arg_manifest_path()
+        .arg_lockfile_path()
         .after_help(color_print::cstr!(
             "Run `<cyan,bold>cargo help metadata</>` for more detailed information.\n"
         ))

src/cargo/core/workspace.rs

@@ -103,6 +103,9 @@ pub struct Workspace<'gctx> {
     // file. This is set for `cargo install` without `--locked`.
     ignore_lock: bool,
 
+    // Requested path of the lockfile (i.e. passed as the cli flag)
+    requested_lockfile_path: Option<PathBuf>,
+
     /// The resolver behavior specified with the `resolver` field.
     resolve_behavior: ResolveBehavior,
     resolve_honors_rust_version: bool,
@@ -237,6 +240,7 @@ impl<'gctx> Workspace<'gctx> {
             require_optional_deps: true,
             loaded_packages: RefCell::new(HashMap::new()),
             ignore_lock: false,
+            requested_lockfile_path: None,
             resolve_behavior: ResolveBehavior::V1,
             resolve_honors_rust_version: false,
             custom_metadata: None,
@@ -647,6 +651,14 @@ impl<'gctx> Workspace<'gctx> {
         self
     }
 
+    pub fn requested_lockfile_path(&self) -> Option<&PathBuf> {
+        self.requested_lockfile_path.as_ref()
+    }
+
+    pub fn set_requested_lockfile_path(&mut self, path: Option<PathBuf>) {
+        self.requested_lockfile_path = path;
+    }
+
     /// Get the lowest-common denominator `package.rust-version` within the workspace, if specified
     /// anywhere
     pub fn rust_version(&self) -> Option<&RustVersion> {

src/cargo/ops/lockfile.rs

@@ -1,19 +1,20 @@
-use std::io::prelude::*;
-
 use crate::core::{resolver, Resolve, ResolveVersion, Workspace};
 use crate::util::errors::CargoResult;
 use crate::util::Filesystem;
+use std::io::prelude::*;
 
 use anyhow::Context as _;
 
+pub const LOCKFILE_NAME: &str = "Cargo.lock";
+
 #[tracing::instrument(skip_all)]
 pub fn load_pkg_lockfile(ws: &Workspace<'_>) -> CargoResult<Option<Resolve>> {
     let lock_root = lock_root(ws);
-    if !lock_root.as_path_unlocked().join("Cargo.lock").exists() {
+    if !lock_root.as_path_unlocked().join(LOCKFILE_NAME).exists() {
         return Ok(None);
     }
 
-    let mut f = lock_root.open_ro_shared("Cargo.lock", ws.gctx(), "Cargo.lock file")?;
+    let mut f = lock_root.open_ro_shared(LOCKFILE_NAME, ws.gctx(), "Cargo.lock file")?;
 
     let mut s = String::new();
     f.read_to_string(&mut s)
@@ -58,7 +59,7 @@ pub fn write_pkg_lockfile(ws: &Workspace<'_>, resolve: &mut Resolve) -> CargoRes
             "the lock file {} needs to be updated but {} was passed to prevent this\n\
              If you want to try to generate the lock file without accessing the network, \
              remove the {} flag and use --offline instead.",
-            lock_root.as_path_unlocked().join("Cargo.lock").display(),
+            lock_root.as_path_unlocked().join(LOCKFILE_NAME).display(),
             flag,
             flag
         );
@@ -84,7 +85,7 @@ pub fn write_pkg_lockfile(ws: &Workspace<'_>, resolve: &mut Resolve) -> CargoRes
 
     // Ok, if that didn't work just write it out
     lock_root
-        .open_rw_exclusive_create("Cargo.lock", ws.gctx(), "Cargo.lock file")
+        .open_rw_exclusive_create(LOCKFILE_NAME, ws.gctx(), "Cargo.lock file")
         .and_then(|mut f| {
             f.file().set_len(0)?;
             f.write_all(out.as_bytes())?;
@@ -93,7 +94,7 @@ pub fn write_pkg_lockfile(ws: &Workspace<'_>, resolve: &mut Resolve) -> CargoRes
         .with_context(|| {
             format!(
                 "failed to write {}",
-                lock_root.as_path_unlocked().join("Cargo.lock").display()
+                lock_root.as_path_unlocked().join(LOCKFILE_NAME).display()
             )
         })?;
     Ok(true)
@@ -105,7 +106,7 @@ fn resolve_to_string_orig(
 ) -> (Option<String>, String, Filesystem) {
     // Load the original lock file if it exists.
     let lock_root = lock_root(ws);
-    let orig = lock_root.open_ro_shared("Cargo.lock", ws.gctx(), "Cargo.lock file");
+    let orig = lock_root.open_ro_shared(LOCKFILE_NAME, ws.gctx(), "Cargo.lock file");
     let orig = orig.and_then(|mut f| {
         let mut s = String::new();
         f.read_to_string(&mut s)?;
@@ -247,6 +248,14 @@ fn emit_package(dep: &toml::Table, out: &mut String) {
 }
 
 fn lock_root(ws: &Workspace<'_>) -> Filesystem {
+    if let Some(requested) = ws.requested_lockfile_path() {
+        return Filesystem::new(
+            requested
+                .parent()
+                .unwrap_or_else(|| unreachable!("Lockfile path can't be root"))
+                .to_owned(),
+        );
+    }
     if ws.root_maybe().is_embedded() {
         ws.target_dir()
     } else {

src/cargo/util/command_prelude.rs

@@ -1,6 +1,7 @@
 use crate::core::compiler::{BuildConfig, MessageFormat, TimingOutput};
 use crate::core::resolver::CliFeatures;
 use crate::core::{Edition, Workspace};
+use crate::ops::lockfile::LOCKFILE_NAME;
 use crate::ops::registry::RegistryOrIndex;
 use crate::ops::{CompileFilter, CompileOptions, NewOptions, Packages, VersionControl};
 use crate::util::important_paths::find_root_manifest_for_wd;
@@ -12,13 +13,14 @@ use crate::util::{
     print_available_packages, print_available_tests,
 };
 use crate::CargoResult;
-use anyhow::bail;
+use anyhow::{bail, Context};
 use cargo_util::paths;
 use cargo_util_schemas::manifest::ProfileName;
 use cargo_util_schemas::manifest::RegistryName;
 use cargo_util_schemas::manifest::StringOrVec;
 use clap::builder::UnknownArgumentValueParser;
 use std::ffi::{OsStr, OsString};
+use std::fs;
 use std::path::Path;
 use std::path::PathBuf;
 
@@ -295,6 +297,15 @@ pub trait CommandExt: Sized {
         )
     }
 
+    fn arg_lockfile_path(self) -> Self {
+        self._arg(
+            opt("lockfile-path", "Path to the Cargo.lock file (unstable)")
+                .value_name("FILE")
+                // TODO: seemed to be the best option, but maybe should be something else?
+                .help_heading(heading::MANIFEST_OPTIONS),
+        )
+    }
+
     fn arg_message_format(self) -> Self {
         self._arg(multi_opt("message-format", "FMT", "Error format"))
     }
@@ -517,14 +528,20 @@ pub trait ArgMatchesExt {
         root_manifest(self._value_of("manifest-path").map(Path::new), gctx)
     }
 
+    fn lockfile_path(&self, gctx: &GlobalContext) -> CargoResult<Option<PathBuf>> {
+        lockfile_path(self._value_of("lockfile-path").map(Path::new), gctx)
+    }
+
     #[tracing::instrument(skip_all)]
     fn workspace<'a>(&self, gctx: &'a GlobalContext) -> CargoResult<Workspace<'a>> {
         let root = self.root_manifest(gctx)?;
+        let lockfile_path = self.lockfile_path(gctx)?;
         let mut ws = Workspace::new(&root, gctx)?;
         ws.set_resolve_honors_rust_version(self.honor_rust_version());
         if gctx.cli_unstable().avoid_dev_deps {
             ws.set_require_optional_deps(false);
         }
+        ws.set_requested_lockfile_path(lockfile_path);
         Ok(ws)
     }
 
@@ -986,6 +1003,64 @@ pub fn root_manifest(manifest_path: Option<&Path>, gctx: &GlobalContext) -> Carg
     }
 }
 
+pub fn lockfile_path(
+    lockfile_path: Option<&Path>,
+    gctx: &GlobalContext,
+) -> CargoResult<Option<PathBuf>> {
+    let path;
+
+    if let Some(lockfile_path) = lockfile_path {
+        if !gctx.cli_unstable().unstable_options {
+            bail!("`--lockfile-path` option requires `-Zunstable-options`")
+        }
+
+        if lockfile_path.is_absolute() {
+            path = lockfile_path.to_path_buf();
+        } else {
+            path = gctx.cwd().join(lockfile_path);
+        }
+
+        if !path.ends_with(LOCKFILE_NAME) && !crate::util::toml::is_embedded(&path) {
+            bail!(
+                "the lockfile-path must be a path to a {} file",
+                LOCKFILE_NAME
+            )
+        }
+        if path.is_dir() {
+            bail!(
+                "lockfile path `{}` is a directory but expected a file",
+                lockfile_path.display()
+            )
+        }
+        if !path.exists() {
+            // Root case should already be covered above
+            let parent_path = lockfile_path
+                .parent()
+                .unwrap_or_else(|| unreachable!("Lockfile path can't be root"));
+
+            let exists = parent_path.try_exists().with_context(|| {
+                format!(
+                    "Failed to fetch lock file's parent path metadata {}",
+                    parent_path.display()
+                )
+            })?;
+
+            if !exists {
+                fs::create_dir_all(parent_path).with_context(|| {
+                    format!(
+                        "Failed to create lockfile-path parent directory {}",
+                        parent_path.display()
+                    )
+                })?
+            }
+        }
+
+        return Ok(Some(path));
+    }
+
+    Ok(None)
+}
+
 #[track_caller]
 pub fn ignore_unknown<T: Default>(r: Result<T, clap::parser::MatchesError>) -> T {
     match r {