feat lockfile-path and related tests refactoring

Author: ifropc

src/bin/cargo/commands/fix.rs

@@ -1,6 +1,5 @@
 use crate::command_prelude::*;
 use cargo::core::Workspace;
-use std::path::Path;
 
 use cargo::ops;
 
@@ -77,8 +76,7 @@ pub fn exec(gctx: &mut GlobalContext, args: &ArgMatches) -> CliResult {
     // Can't use workspace() to avoid using -Zavoid-dev-deps (if passed)
     let mut ws = Workspace::new(&root_manifest, gctx)?;
     ws.set_resolve_honors_rust_version(args.honor_rust_version());
-    let lockfile_path =
-        lockfile_path(args.get_one::<String>("lockfile-path").map(Path::new), gctx)?;
+    let lockfile_path = args.lockfile_path(gctx)?;
     ws.set_requested_lockfile_path(lockfile_path.clone());
 
     let mut opts = args.compile_options(gctx, mode, Some(&ws), ProfileChecking::LegacyTestOnly)?;
@@ -92,7 +90,6 @@ pub fn exec(gctx: &mut GlobalContext, args: &ArgMatches) -> CliResult {
         gctx,
         &ws,
         &root_manifest,
-        lockfile_path,
         &mut ops::FixOptions {
             edition: args.flag("edition"),
             idioms: args.flag("edition-idioms"),
@@ -101,6 +98,7 @@ pub fn exec(gctx: &mut GlobalContext, args: &ArgMatches) -> CliResult {
             allow_no_vcs: args.flag("allow-no-vcs"),
             allow_staged: args.flag("allow-staged"),
             broken_code: args.flag("broken-code"),
+            requested_lockfile_path: lockfile_path,
         },
     )?;
     Ok(())

src/cargo/core/workspace.rs

@@ -651,16 +651,17 @@ impl<'gctx> Workspace<'gctx> {
         self
     }
 
+    /// Returns the directory where the lockfile is in.
     pub fn lock_root(&self) -> Filesystem {
         if let Some(requested) = self.requested_lockfile_path.as_ref() {
             return Filesystem::new(
                 requested
                     .parent()
-                    .unwrap_or_else(|| unreachable!("Lockfile path can't be root"))
+                    .expect("Lockfile path can't be root")
                     .to_owned(),
             );
         }
-        return self.default_lock_root();
+        self.default_lock_root()
     }
 
     fn default_lock_root(&self) -> Filesystem {

src/cargo/ops/fix.rs

@@ -97,13 +97,13 @@ pub struct FixOptions {
     pub allow_no_vcs: bool,
     pub allow_staged: bool,
     pub broken_code: bool,
+    pub requested_lockfile_path: Option<PathBuf>,
 }
 
 pub fn fix(
     gctx: &GlobalContext,
     original_ws: &Workspace<'_>,
     root_manifest: &Path,
-    requested_lockfile_path: Option<PathBuf>,
     opts: &mut FixOptions,
 ) -> CargoResult<()> {
     check_version_control(gctx, opts)?;
@@ -122,9 +122,7 @@ pub fn fix(
     }
     let mut ws = Workspace::new(&root_manifest, gctx)?;
     ws.set_resolve_honors_rust_version(Some(original_ws.resolve_honors_rust_version()));
-    if let Some(p) = requested_lockfile_path {
-        ws.set_requested_lockfile_path(Some(p))
-    }
+    ws.set_requested_lockfile_path(opts.requested_lockfile_path.clone());
 
     // Spin up our lock server, which our subprocesses will use to synchronize fixes.
     let lock_server = LockServer::new()?;

src/cargo/util/command_prelude.rs

@@ -1014,7 +1014,7 @@ pub fn lockfile_path(
 
     let path = gctx.cwd().join(lockfile_path);
 
-    if !path.ends_with(LOCKFILE_NAME) && !crate::util::toml::is_embedded(&path) {
+    if !path.ends_with(LOCKFILE_NAME) {
         bail!("the lockfile-path must be a path to a {LOCKFILE_NAME} file")
     }
     if path.is_dir() {