refactoring: move lock_root into worspace

Author: ifropc

src/bin/cargo/commands/fix.rs

@@ -79,7 +79,7 @@ pub fn exec(gctx: &mut GlobalContext, args: &ArgMatches) -> CliResult {
     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)?;
-    ws.set_requested_lockfile_path(lockfile_path);
+    ws.set_requested_lockfile_path(lockfile_path.clone());
 
     let mut opts = args.compile_options(gctx, mode, Some(&ws), ProfileChecking::LegacyTestOnly)?;
 
@@ -92,6 +92,7 @@ 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"),

src/cargo/core/workspace.rs

@@ -651,8 +651,24 @@ impl<'gctx> Workspace<'gctx> {
         self
     }
 
-    pub fn requested_lockfile_path(&self) -> Option<&PathBuf> {
-        self.requested_lockfile_path.as_ref()
+    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"))
+                    .to_owned(),
+            );
+        }
+        return self.default_lock_root();
+    }
+
+    fn default_lock_root(&self) -> Filesystem {
+        if self.root_maybe().is_embedded() {
+            self.target_dir()
+        } else {
+            Filesystem::new(self.root().to_owned())
+        }
     }
 
     pub fn set_requested_lockfile_path(&mut self, path: Option<PathBuf>) {

src/cargo/ops/cargo_package.rs

@@ -6,13 +6,15 @@ use std::path::{Path, PathBuf};
 use std::sync::Arc;
 use std::task::Poll;
 
+use super::RegistryOrIndex;
 use crate::core::compiler::{BuildConfig, CompileMode, DefaultExecutor, Executor};
 use crate::core::dependency::DepKind;
 use crate::core::manifest::Target;
 use crate::core::resolver::CliFeatures;
 use crate::core::resolver::HasDevUnits;
 use crate::core::{Feature, PackageIdSpecQuery, Shell, Verbosity, Workspace};
 use crate::core::{Package, PackageId, PackageSet, Resolve, SourceId};
+use crate::ops::lockfile::LOCKFILE_NAME;
 use crate::sources::registry::index::{IndexPackage, RegistryDependency};
 use crate::sources::{PathSource, SourceConfigMap, CRATES_IO_REGISTRY};
 use crate::util::cache_lock::CacheLockMode;
@@ -32,8 +34,6 @@ use tar::{Archive, Builder, EntryType, Header, HeaderMode};
 use tracing::debug;
 use unicase::Ascii as UncasedAscii;
 
-use super::RegistryOrIndex;
-
 #[derive(Clone)]
 pub struct PackageOpts<'gctx> {
     pub gctx: &'gctx GlobalContext,
@@ -248,10 +248,10 @@ pub fn package(ws: &Workspace<'_>, opts: &PackageOpts<'_>) -> CargoResult<Vec<Fi
     }
     let pkgs = ws.members_with_features(specs, &opts.cli_features)?;
 
-    let default_lockfile = ws.root().join("Cargo.lock");
     if ws
-        .requested_lockfile_path()
-        .unwrap_or_else(|| &default_lockfile)
+        .lock_root()
+        .as_path_unlocked()
+        .join(LOCKFILE_NAME)
         .exists()
     {
         // Make sure the Cargo.lock is up-to-date and valid.

src/cargo/ops/fix.rs

@@ -103,6 +103,7 @@ 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)?;
@@ -121,8 +122,8 @@ 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) = original_ws.requested_lockfile_path() {
-        ws.set_requested_lockfile_path(Some(p.clone()))
+    if let Some(p) = requested_lockfile_path {
+        ws.set_requested_lockfile_path(Some(p))
     }
 
     // Spin up our lock server, which our subprocesses will use to synchronize fixes.

src/cargo/ops/lockfile.rs

@@ -10,7 +10,7 @@ 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);
+    let lock_root = ws.lock_root();
     if !lock_root.as_path_unlocked().join(LOCKFILE_NAME).exists() {
         return Ok(None);
     }
@@ -106,7 +106,7 @@ fn resolve_to_string_orig(
     resolve: &Resolve,
 ) -> (Option<String>, String, Filesystem) {
     // Load the original lock file if it exists.
-    let lock_root = lock_root(ws);
+    let lock_root = ws.lock_root();
     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();
@@ -247,19 +247,3 @@ fn emit_package(dep: &toml::Table, out: &mut String) {
         out.push_str(&format!("replace = {}\n\n", &dep["replace"]));
     }
 }
-
-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 {
-        Filesystem::new(ws.root().to_owned())
-    }
-}