Add a dry_run argument to resolve_ws().

benches/benchsuite/benches/resolve.rs

@@ -33,6 +33,7 @@ fn do_resolve<'gctx>(gctx: &'gctx GlobalContext, ws_root: &Path) -> ResolveInfo<
     let force_all_targets = ForceAllTargets::No;
     // Do an initial run to download anything necessary so that it does
     // not confuse criterion's warmup.
+    let dry_run = false;
     let ws_resolve = cargo::ops::resolve_ws_with_opts(
         &ws,
         &mut target_data,
@@ -41,6 +42,7 @@ fn do_resolve<'gctx>(gctx: &'gctx GlobalContext, ws_root: &Path) -> ResolveInfo<
         &specs,
         has_dev_units,
         force_all_targets,
+        dry_run,
     )
     .unwrap();
     ResolveInfo {
@@ -71,6 +73,7 @@ fn resolve_ws(c: &mut Criterion) {
         // iterator once, and we don't want to call `do_resolve` in every
         // "step", since that would just be some useless work.
         let mut lazy_info = None;
+        let dry_run = false;
         group.bench_function(&ws_name, |b| {
             let ResolveInfo {
                 ws,
@@ -91,6 +94,7 @@ fn resolve_ws(c: &mut Criterion) {
                     specs,
                     *has_dev_units,
                     *force_all_targets,
+                    dry_run,
                 )
                 .unwrap();
             })

src/bin/cargo/commands/add.rs

@@ -214,11 +214,9 @@ pub fn exec(gctx: &mut GlobalContext, args: &ArgMatches) -> CliResult {
     };
     add(&ws, &options)?;
 
-    if !dry_run {
+    // Reload the workspace since we've changed dependencies
-        // Reload the workspace since we've changed dependencies
+    let ws = args.workspace(gctx)?;
-        let ws = args.workspace(gctx)?;
+    resolve_ws(&ws, dry_run)?;
-        resolve_ws(&ws)?;
-    }
 
     Ok(())
 }

src/bin/cargo/commands/remove.rs

@@ -121,7 +121,7 @@ pub fn exec(gctx: &mut GlobalContext, args: &ArgMatches) -> CliResult {
             ws.gctx()
                 .shell()
                 .set_verbosity(cargo::core::Verbosity::Quiet);
-            let resolve = resolve_ws(&ws);
+            let resolve = resolve_ws(&ws, dry_run);
             ws.gctx().shell().set_verbosity(verbosity);
             resolve?.1
         };
@@ -129,7 +129,7 @@ pub fn exec(gctx: &mut GlobalContext, args: &ArgMatches) -> CliResult {
         // Attempt to gc unused patches and re-resolve if anything is removed
         if gc_unused_patches(&workspace, &resolve)? {
             let ws = args.workspace(gctx)?;
-            resolve_ws(&ws)?;
+            resolve_ws(&ws, dry_run)?;
         }
     }
     Ok(())

src/cargo/core/compiler/standard_lib.rs

@@ -149,6 +149,7 @@ pub fn resolve_std<'gctx>(
     let cli_features = CliFeatures::from_command_line(
         &features, /*all_features*/ false, /*uses_default_features*/ false,
     )?;
+    let dry_run = false;
     let resolve = ops::resolve_ws_with_opts(
         &std_ws,
         target_data,
@@ -157,6 +158,7 @@ pub fn resolve_std<'gctx>(
         &specs,
         HasDevUnits::No,
         crate::core::resolver::features::ForceAllTargets::No,
+        dry_run,
     )?;
     Ok((
         resolve.pkg_set,

src/cargo/ops/cargo_clean.rs

@@ -77,7 +77,14 @@ pub fn clean(ws: &Workspace<'_>, opts: &CleanOptions<'_>) -> CargoResult<()> {
         if opts.spec.is_empty() {
             clean_ctx.remove_paths(&[target_dir.into_path_unlocked()])?;
         } else {
-            clean_specs(&mut clean_ctx, &ws, &profiles, &opts.targets, &opts.spec)?;
+            clean_specs(
+                &mut clean_ctx,
+                &ws,
+                &profiles,
+                &opts.targets,
+                &opts.spec,
+                opts.dry_run,
+            )?;
         }
     }
 
@@ -91,11 +98,12 @@ fn clean_specs(
     profiles: &Profiles,
     targets: &[String],
     spec: &[String],
+    dry_run: bool,
 ) -> CargoResult<()> {
     // Clean specific packages.
     let requested_kinds = CompileKind::from_requested_targets(clean_ctx.gctx, targets)?;
     let target_data = RustcTargetData::new(ws, &requested_kinds)?;
-    let (pkg_set, resolve) = ops::resolve_ws(ws)?;
+    let (pkg_set, resolve) = ops::resolve_ws(ws, dry_run)?;
     let prof_dir_name = profiles.get_dir_name();
     let host_layout = Layout::new(ws, None, &prof_dir_name)?;
     // Convert requested kinds to a Vec of layouts.

src/cargo/ops/cargo_compile/mod.rs

@@ -264,6 +264,7 @@ pub fn create_bcx<'a, 'gctx>(
             HasDevUnits::No
         }
     };
+    let dry_run = false;
     let resolve = ops::resolve_ws_with_opts(
         ws,
         &mut target_data,
@@ -272,6 +273,7 @@ pub fn create_bcx<'a, 'gctx>(
         &specs,
         has_dev_units,
         crate::core::resolver::features::ForceAllTargets::No,
+        dry_run,
     )?;
     let WorkspaceResolve {
         mut pkg_set,

src/cargo/ops/cargo_fetch.rs

@@ -19,7 +19,8 @@ pub fn fetch<'a>(
     options: &FetchOptions<'a>,
 ) -> CargoResult<(Resolve, PackageSet<'a>)> {
     ws.emit_warnings()?;
-    let (mut packages, resolve) = ops::resolve_ws(ws)?;
+    let dry_run = false;
+    let (mut packages, resolve) = ops::resolve_ws(ws, dry_run)?;
 
     let jobs = Some(JobsConfig::Integer(1));
     let keep_going = false;

src/cargo/ops/cargo_install.rs

@@ -561,7 +561,8 @@ impl<'gctx> InstallablePackage<'gctx> {
         // It would be best if `source` could be passed in here to avoid a
         // duplicate "Updating", but since `source` is taken by value, then it
         // wouldn't be available for `compile_ws`.
-        let (pkg_set, resolve) = ops::resolve_ws(&self.ws)?;
+        let dry_run = false;
+        let (pkg_set, resolve) = ops::resolve_ws(&self.ws, dry_run)?;
         ops::check_yanked(
             self.ws.gctx(),
             &pkg_set,

src/cargo/ops/cargo_output_metadata.rs

@@ -142,6 +142,7 @@ fn build_resolve_graph(
 
     // Note that even with --filter-platform we end up downloading host dependencies as well,
     // as that is the behavior of download_accessible.
+    let dry_run = false;
     let ws_resolve = ops::resolve_ws_with_opts(
         ws,
         &mut target_data,
@@ -150,6 +151,7 @@ fn build_resolve_graph(
         &specs,
         HasDevUnits::Yes,
         force_all,
+        dry_run,
     )?;
 
     let package_map: BTreeMap<PackageId, Package> = ws_resolve

src/cargo/ops/cargo_package.rs

@@ -190,7 +190,8 @@ pub fn package(ws: &Workspace<'_>, opts: &PackageOpts<'_>) -> CargoResult<Option
 
     if ws.root().join("Cargo.lock").exists() {
         // Make sure the Cargo.lock is up-to-date and valid.
-        let _ = ops::resolve_ws(ws)?;
+        let dry_run = false;
+        let _ = ops::resolve_ws(ws, dry_run)?;
         // If Cargo.lock does not exist, it will be generated by `build_lock`
         // below, and will be validated during the verification step.
     }

src/cargo/ops/fix.rs

@@ -506,6 +506,7 @@ fn check_resolver_change<'gctx>(
     assert_eq!(ws.resolve_behavior(), ResolveBehavior::V1);
     let specs = opts.compile_opts.spec.to_package_id_specs(ws)?;
     let mut resolve_differences = |has_dev_units| -> CargoResult<(WorkspaceResolve<'_>, DiffMap)> {
+        let dry_run = false;
         let ws_resolve = ops::resolve_ws_with_opts(
             ws,
             target_data,
@@ -514,6 +515,7 @@ fn check_resolver_change<'gctx>(
             &specs,
             has_dev_units,
             crate::core::resolver::features::ForceAllTargets::No,
+            dry_run,
         )?;
 
         let feature_opts = FeatureOpts::new_behavior(ResolveBehavior::V2, has_dev_units);

src/cargo/ops/resolve.rs

@@ -115,9 +115,9 @@ version. This may also occur with an optional dependency that is not enabled.";
 ///
 /// This is a simple interface used by commands like `clean`, `fetch`, and
 /// `package`, which don't specify any options or features.
-pub fn resolve_ws<'a>(ws: &Workspace<'a>) -> CargoResult<(PackageSet<'a>, Resolve)> {
+pub fn resolve_ws<'a>(ws: &Workspace<'a>, dry_run: bool) -> CargoResult<(PackageSet<'a>, Resolve)> {
     let mut registry = PackageRegistry::new(ws.gctx())?;
-    let resolve = resolve_with_registry(ws, &mut registry)?;
+    let resolve = resolve_with_registry(ws, &mut registry, dry_run)?;
     let packages = get_resolved_packages(&resolve, registry)?;
     Ok((packages, resolve))
 }
@@ -140,6 +140,7 @@ pub fn resolve_ws_with_opts<'gctx>(
     specs: &[PackageIdSpec],
     has_dev_units: HasDevUnits,
     force_all_targets: ForceAllTargets,
+    dry_run: bool,
 ) -> CargoResult<WorkspaceResolve<'gctx>> {
     let mut registry = PackageRegistry::new(ws.gctx())?;
     let (resolve, resolved_with_overrides) = if ws.ignore_lock() {
@@ -160,7 +161,7 @@ pub fn resolve_ws_with_opts<'gctx>(
     } else if ws.require_optional_deps() {
         // First, resolve the root_package's *listed* dependencies, as well as
         // downloading and updating all remotes and such.
-        let resolve = resolve_with_registry(ws, &mut registry)?;
+        let resolve = resolve_with_registry(ws, &mut registry, dry_run)?;
         // No need to add patches again, `resolve_with_registry` has done it.
         let add_patches = false;
 
@@ -269,6 +270,7 @@ pub fn resolve_ws_with_opts<'gctx>(
 fn resolve_with_registry<'gctx>(
     ws: &Workspace<'gctx>,
     registry: &mut PackageRegistry<'gctx>,
+    dry_run: bool,
 ) -> CargoResult<Resolve> {
     let prev = ops::load_pkg_lockfile(ws)?;
     let mut resolve = resolve_with_previous(
@@ -283,7 +285,11 @@ fn resolve_with_registry<'gctx>(
     )?;
 
     let print = if !ws.is_ephemeral() && ws.require_optional_deps() {
-        ops::write_pkg_lockfile(ws, &mut resolve)?
+        if !dry_run {
+            ops::write_pkg_lockfile(ws, &mut resolve)?
+        } else {
+            true
+        }
     } else {
         // This mostly represents
         // - `cargo install --locked` and the only change is the package is no longer local but

src/cargo/ops/tree/mod.rs

@@ -131,6 +131,7 @@ pub fn build_and_print(ws: &Workspace<'_>, opts: &TreeOptions) -> CargoResult<()
     } else {
         ForceAllTargets::No
     };
+    let dry_run = false;
     let ws_resolve = ops::resolve_ws_with_opts(
         ws,
         &mut target_data,
@@ -139,6 +140,7 @@ pub fn build_and_print(ws: &Workspace<'_>, opts: &TreeOptions) -> CargoResult<()
         &specs,
         has_dev,
         force_all,
+        dry_run,
     )?;
 
     let package_map: HashMap<PackageId, &Package> = ws_resolve

src/cargo/ops/vendor.rs

@@ -80,6 +80,7 @@ fn sync(
     workspaces: &[&Workspace<'_>],
     opts: &VendorOptions<'_>,
 ) -> CargoResult<VendorConfig> {
+    let dry_run = false;
     let canonical_destination = try_canonicalize(opts.destination);
     let canonical_destination = canonical_destination.as_deref().unwrap_or(opts.destination);
     let dest_dir_already_exists = canonical_destination.exists();
@@ -112,7 +113,7 @@ fn sync(
     // crate to work with.
     for ws in workspaces {
         let (packages, resolve) =
-            ops::resolve_ws(ws).with_context(|| "failed to load pkg lockfile")?;
+            ops::resolve_ws(ws, dry_run).with_context(|| "failed to load pkg lockfile")?;
 
         packages
             .get_many(resolve.iter())
@@ -144,7 +145,7 @@ fn sync(
     // tables about them.
     for ws in workspaces {
         let (packages, resolve) =
-            ops::resolve_ws(ws).with_context(|| "failed to load pkg lockfile")?;
+            ops::resolve_ws(ws, dry_run).with_context(|| "failed to load pkg lockfile")?;
 
         packages
             .get_many(resolve.iter())