Add cargo update --breaking

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();
             })

crates/cargo-test-support/src/compare.rs

@@ -176,6 +176,7 @@ static E2E_LITERAL_REDACTIONS: &[(&str, &str)] = &[
     ("[DIRTY]", "       Dirty"),
     ("[LOCKING]", "     Locking"),
     ("[UPDATING]", "    Updating"),
+    ("[UPGRADING]", "   Upgrading"),
     ("[ADDING]", "      Adding"),
     ("[REMOVING]", "    Removing"),
     ("[REMOVED]", "     Removed"),

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
-        let ws = args.workspace(gctx)?;
-        resolve_ws(&ws)?;
-    }
+    // Reload the workspace since we've changed dependencies
+    let ws = args.workspace(gctx)?;
+    resolve_ws(&ws, dry_run)?;
 
     Ok(())
 }

src/bin/cargo/commands/remove.rs

@@ -121,15 +121,15 @@ 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
         };
 
         // 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/bin/cargo/commands/update.rs

@@ -35,6 +35,13 @@ pub fn cli() -> Command {
                 .value_name("PRECISE")
                 .requires("package-group"),
         )
+        .arg(
+            flag(
+                "breaking",
+                "Upgrade [SPEC] to latest breaking versions, unless pinned (unstable)",
+            )
+            .short('b'),
+        )
         .arg_silent_suggestion()
         .arg(
             flag("workspace", "Only update the workspace packages")
@@ -59,7 +66,8 @@ pub fn exec(gctx: &mut GlobalContext, args: &ArgMatches) -> CliResult {
             gctx.cli_unstable().msrv_policy,
         )?;
     }
-    let ws = args.workspace(gctx)?;
+
+    let mut ws = args.workspace(gctx)?;
 
     if args.is_present_with_zero_values("package") {
         print_available_packages(&ws)?;
@@ -89,6 +97,24 @@ pub fn exec(gctx: &mut GlobalContext, args: &ArgMatches) -> CliResult {
         workspace: args.flag("workspace"),
         gctx,
     };
-    ops::update_lockfile(&ws, &update_opts)?;
+
+    if args.flag("breaking") {
+        gctx.cli_unstable()
+            .fail_if_stable_opt("--breaking", 12425)?;
+
+        let upgrades = ops::upgrade_manifests(&mut ws, &update_opts.to_update)?;
+        ops::resolve_ws(&ws, update_opts.dry_run)?;
+        ops::write_manifest_upgrades(&ws, &upgrades, update_opts.dry_run)?;
+
+        if update_opts.dry_run {
+            update_opts
+                .gctx
+                .shell()
+                .warn("aborting update due to dry run")?;
+        }
+    } else {
+        ops::update_lockfile(&ws, &update_opts)?;
+    }
+
     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/core/summary.rs

@@ -103,15 +103,25 @@ impl Summary {
         Rc::make_mut(&mut self.inner).checksum = Some(cksum);
     }
 
-    pub fn map_dependencies<F>(mut self, f: F) -> Summary
+    pub fn map_dependencies<F>(self, mut f: F) -> Summary
     where
         F: FnMut(Dependency) -> Dependency,
+    {
+        self.try_map_dependencies(|dep| Ok(f(dep))).unwrap()
+    }
+
+    pub fn try_map_dependencies<F>(mut self, f: F) -> CargoResult<Summary>
+    where
+        F: FnMut(Dependency) -> CargoResult<Dependency>,
     {
         {
             let slot = &mut Rc::make_mut(&mut self.inner).dependencies;
-            *slot = mem::take(slot).into_iter().map(f).collect();
+            *slot = mem::take(slot)
+                .into_iter()
+                .map(f)
+                .collect::<CargoResult<_>>()?;
         }
-        self
+        Ok(self)
     }
 
     pub fn map_source(self, to_replace: SourceId, replace_with: SourceId) -> Summary {

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.
     }