From b3d865e11c1c496e4803afcb8cadc35200b46e0d Mon Sep 17 00:00:00 2001
From: Eric Huss <eric@huss.org>
Date: Wed, 17 Feb 2021 20:11:15 -0800
Subject: [PATCH 01/11] Some minor refactoring of `fix` code.

There shouldn't be any functional changes here.

* Some doc comments.
* Construct `FixArgs` at once so it doesn't need to bother with unnecessary Options.
* Remove IdiomEditionMismatch, it is not used.
* Use a general deduping mechanism for fix messages.
---
 src/cargo/ops/fix.rs                | 144 +++++++++++++++-------------
 src/cargo/util/diagnostic_server.rs |  48 ++--------
 2 files changed, 83 insertions(+), 109 deletions(-)

diff --git a/src/cargo/ops/fix.rs b/src/cargo/ops/fix.rs
index 1ebcef67bbc..0ba8b41c6b4 100644
--- a/src/cargo/ops/fix.rs
+++ b/src/cargo/ops/fix.rs
@@ -45,7 +45,7 @@ use std::path::{Path, PathBuf};
 use std::process::{self, Command, ExitStatus};
 use std::str;
 
-use anyhow::{Context, Error};
+use anyhow::{bail, Context, Error};
 use log::{debug, trace, warn};
 use rustfix::diagnostics::Diagnostic;
 use rustfix::{self, CodeFix};
@@ -130,7 +130,7 @@ fn check_version_control(config: &Config, opts: &FixOptions<'_>) -> CargoResult<
         return Ok(());
     }
     if !existing_vcs_repo(config.cwd(), config.cwd()) {
-        anyhow::bail!(
+        bail!(
             "no VCS found for this package and `cargo fix` can potentially \
              perform destructive changes; if you'd like to suppress this \
              error pass `--allow-no-vcs`"
@@ -185,7 +185,7 @@ fn check_version_control(config: &Config, opts: &FixOptions<'_>) -> CargoResult<
         files_list.push_str(" (staged)\n");
     }
 
-    anyhow::bail!(
+    bail!(
         "the working directory of this package has uncommitted changes, and \
          `cargo fix` can potentially perform destructive changes; if you'd \
          like to suppress this error pass `--allow-dirty`, `--allow-staged`, \
@@ -197,6 +197,14 @@ fn check_version_control(config: &Config, opts: &FixOptions<'_>) -> CargoResult<
     );
 }
 
+/// Entry point for `cargo` running as a proxy for `rustc`.
+///
+/// This is called every time `cargo` is run to check if it is in proxy mode.
+///
+/// Returns `false` if `fix` is not being run (not in proxy mode). Returns
+/// `true` if in `fix` proxy mode, and the fix was complete without any
+/// warnings or errors. If there are warnings or errors, this does not return,
+/// and the process exits with the corresponding `rustc` exit code.
 pub fn fix_maybe_exec_rustc() -> CargoResult<bool> {
     let lock_addr = match env::var(FIX_ENV) {
         Ok(s) => s,
@@ -206,17 +214,13 @@ pub fn fix_maybe_exec_rustc() -> CargoResult<bool> {
     let args = FixArgs::get()?;
     trace!("cargo-fix as rustc got file {:?}", args.file);
 
-    let rustc = args.rustc.as_ref().expect("fix wrapper rustc was not set");
     let workspace_rustc = std::env::var("RUSTC_WORKSPACE_WRAPPER")
         .map(PathBuf::from)
         .ok();
-    let rustc = util::process(rustc).wrapped(workspace_rustc.as_ref());
+    let rustc = util::process(&args.rustc).wrapped(workspace_rustc.as_ref());
 
-    let mut fixes = FixedCrate::default();
-    if let Some(path) = &args.file {
-        trace!("start rustfixing {:?}", path);
-        fixes = rustfix_crate(&lock_addr, &rustc, path, &args)?;
-    }
+    trace!("start rustfixing {:?}", args.file);
+    let fixes = rustfix_crate(&lock_addr, &rustc, &args.file, &args)?;
 
     // Ok now we have our final goal of testing out the changes that we applied.
     // If these changes went awry and actually started to cause the crate to
@@ -287,6 +291,10 @@ struct FixedFile {
     original_code: String,
 }
 
+/// Attempts to apply fixes to a single crate.
+///
+/// This runs `rustc` (possibly multiple times) to gather suggestions from the
+/// compiler and applies them to the files on disk.
 fn rustfix_crate(
     lock_addr: &str,
     rustc: &ProcessBuilder,
@@ -578,70 +586,92 @@ fn log_failed_fix(stderr: &[u8]) -> Result<(), Error> {
     Ok(())
 }
 
-#[derive(Default)]
+/// Various command-line options and settings used when `cargo` is running as
+/// a proxy for `rustc` during the fix operation.
 struct FixArgs {
-    file: Option<PathBuf>,
-    prepare_for_edition: PrepareFor,
+    /// This is the `.rs` file that is being fixed.
+    file: PathBuf,
+    /// If `--edition` is used to migrate to the next edition, this is the
+    /// edition we are migrating towards.
+    prepare_for_edition: Option<Edition>,
+    /// `true` if `--edition-idioms` is enabled.
     idioms: bool,
+    /// The current edition.
+    ///
+    /// `None` if on 2015.
     enabled_edition: Option<Edition>,
+    /// Other command-line arguments not reflected by other fields in
+    /// `FixArgs`.
     other: Vec<OsString>,
-    rustc: Option<PathBuf>,
+    /// Path to the `rustc` executable.
+    rustc: PathBuf,
+    /// Console output flags (`--error-format`, `--json`, etc.).
+    ///
+    /// The normal fix procedure always uses `--json`, so it overrides what
+    /// Cargo normally passes when applying fixes. When displaying warnings or
+    /// errors, it will use these flags.
     format_args: Vec<String>,
 }
 
-enum PrepareFor {
-    Next,
-    Edition(Edition),
-    None,
-}
-
-impl Default for PrepareFor {
-    fn default() -> PrepareFor {
-        PrepareFor::None
-    }
-}
-
 impl FixArgs {
     fn get() -> Result<FixArgs, Error> {
-        let mut ret = FixArgs::default();
-
-        ret.rustc = env::args_os().nth(1).map(PathBuf::from);
+        let rustc = env::args_os()
+            .nth(1)
+            .map(PathBuf::from)
+            .ok_or_else(|| anyhow::anyhow!("expected rustc as first argument"))?;
+        let mut file = None;
+        let mut enabled_edition = None;
+        let mut other = Vec::new();
+        let mut format_args = Vec::new();
 
         for arg in env::args_os().skip(2) {
             let path = PathBuf::from(arg);
             if path.extension().and_then(|s| s.to_str()) == Some("rs") && path.exists() {
-                ret.file = Some(path);
+                file = Some(path);
                 continue;
             }
             if let Some(s) = path.to_str() {
                 if let Some(edition) = s.strip_prefix("--edition=") {
-                    ret.enabled_edition = Some(edition.parse()?);
+                    enabled_edition = Some(edition.parse()?);
                     continue;
                 }
                 if s.starts_with("--error-format=") || s.starts_with("--json=") {
                     // Cargo may add error-format in some cases, but `cargo
                     // fix` wants to add its own.
-                    ret.format_args.push(s.to_string());
+                    format_args.push(s.to_string());
                     continue;
                 }
             }
-            ret.other.push(path.into());
+            other.push(path.into());
         }
-        if let Ok(s) = env::var(PREPARE_FOR_ENV) {
-            ret.prepare_for_edition = PrepareFor::Edition(s.parse()?);
+        let file = file.ok_or_else(|| anyhow::anyhow!("could not find .rs file in rustc args"))?;
+        let idioms = env::var(IDIOMS_ENV).is_ok();
+
+        let prepare_for_edition = if let Ok(s) = env::var(PREPARE_FOR_ENV) {
+            Some(s.parse()?)
         } else if env::var(EDITION_ENV).is_ok() {
-            ret.prepare_for_edition = PrepareFor::Next;
-        }
+            match enabled_edition {
+                None | Some(Edition::Edition2015) => Some(Edition::Edition2018),
+                Some(Edition::Edition2018) => Some(Edition::Edition2018), // TODO: Change to 2021 when rustc is ready for it.
+                Some(Edition::Edition2021) => Some(Edition::Edition2021),
+            }
+        } else {
+            None
+        };
 
-        ret.idioms = env::var(IDIOMS_ENV).is_ok();
-        Ok(ret)
+        Ok(FixArgs {
+            file,
+            prepare_for_edition,
+            idioms,
+            enabled_edition,
+            other,
+            rustc,
+            format_args,
+        })
     }
 
     fn apply(&self, cmd: &mut Command) {
-        if let Some(path) = &self.file {
-            cmd.arg(path);
-        }
-
+        cmd.arg(&self.file);
         cmd.args(&self.other).arg("--cap-lints=warn");
         if let Some(edition) = self.enabled_edition {
             cmd.arg("--edition").arg(edition.to_string());
@@ -650,7 +680,7 @@ impl FixArgs {
             }
         }
 
-        if let Some(edition) = self.prepare_for_edition_resolve() {
+        if let Some(edition) = self.prepare_for_edition {
             cmd.arg("-W").arg(format!("rust-{}-compatibility", edition));
         }
     }
@@ -663,7 +693,7 @@ impl FixArgs {
     /// actually be able to fix anything! If it looks like this is happening
     /// then yield an error to the user, indicating that this is happening.
     fn verify_not_preparing_for_enabled_edition(&self) -> CargoResult<()> {
-        let edition = match self.prepare_for_edition_resolve() {
+        let edition = match self.prepare_for_edition {
             Some(s) => s,
             None => return Ok(()),
         };
@@ -674,33 +704,13 @@ impl FixArgs {
         if edition != enabled {
             return Ok(());
         }
-        let path = match &self.file {
-            Some(s) => s,
-            None => return Ok(()),
-        };
 
         Message::EditionAlreadyEnabled {
-            file: path.display().to_string(),
-            edition: edition.to_string(),
+            file: self.file.display().to_string(),
+            edition,
         }
         .post()?;
 
         process::exit(1);
     }
-
-    fn prepare_for_edition_resolve(&self) -> Option<Edition> {
-        match self.prepare_for_edition {
-            PrepareFor::Edition(s) => Some(s),
-            PrepareFor::Next => Some(self.next_edition()),
-            PrepareFor::None => None,
-        }
-    }
-
-    fn next_edition(&self) -> Edition {
-        match self.enabled_edition {
-            None | Some(Edition::Edition2015) => Edition::Edition2018,
-            Some(Edition::Edition2018) => Edition::Edition2018, // TODO: Change to 2021 when rustc is ready for it.
-            Some(Edition::Edition2021) => Edition::Edition2021,
-        }
-    }
 }
diff --git a/src/cargo/util/diagnostic_server.rs b/src/cargo/util/diagnostic_server.rs
index 705c1c989ae..dd75e1c185f 100644
--- a/src/cargo/util/diagnostic_server.rs
+++ b/src/cargo/util/diagnostic_server.rs
@@ -13,6 +13,7 @@ use anyhow::{Context, Error};
 use log::warn;
 use serde::{Deserialize, Serialize};
 
+use crate::core::Edition;
 use crate::util::errors::CargoResult;
 use crate::util::{Config, ProcessBuilder};
 
@@ -28,7 +29,7 @@ const PLEASE_REPORT_THIS_BUG: &str =
      fixing code with the `--broken-code` flag\n\n\
      ";
 
-#[derive(Deserialize, Serialize)]
+#[derive(Deserialize, Serialize, Hash, Eq, PartialEq, Clone)]
 pub enum Message {
     Fixing {
         file: String,
@@ -45,12 +46,7 @@ pub enum Message {
     },
     EditionAlreadyEnabled {
         file: String,
-        edition: String,
-    },
-    IdiomEditionMismatch {
-        file: String,
-        idioms: String,
-        edition: Option<String>,
+        edition: Edition,
     },
 }
 
@@ -80,16 +76,14 @@ impl Message {
 
 pub struct DiagnosticPrinter<'a> {
     config: &'a Config,
-    edition_already_enabled: HashSet<String>,
-    idiom_mismatch: HashSet<String>,
+    dedupe: HashSet<Message>,
 }
 
 impl<'a> DiagnosticPrinter<'a> {
     pub fn new(config: &'a Config) -> DiagnosticPrinter<'a> {
         DiagnosticPrinter {
             config,
-            edition_already_enabled: HashSet::new(),
-            idiom_mismatch: HashSet::new(),
+            dedupe: HashSet::new(),
         }
     }
 
@@ -158,8 +152,7 @@ impl<'a> DiagnosticPrinter<'a> {
                 Ok(())
             }
             Message::EditionAlreadyEnabled { file, edition } => {
-                // Like above, only warn once per file
-                if !self.edition_already_enabled.insert(file.clone()) {
+                if !self.dedupe.insert(msg.clone()) {
                     return Ok(());
                 }
 
@@ -181,35 +174,6 @@ information about transitioning to the {0} edition see:
                 self.config.shell().error(&msg)?;
                 Ok(())
             }
-            Message::IdiomEditionMismatch {
-                file,
-                idioms,
-                edition,
-            } => {
-                // Same as above
-                if !self.idiom_mismatch.insert(file.clone()) {
-                    return Ok(());
-                }
-                self.config.shell().error(&format!(
-                    "\
-cannot migrate to the idioms of the {} edition for `{}`
-because it is compiled {}, which doesn't match {0}
-
-consider migrating to the {0} edition by adding `edition = '{0}'` to
-`Cargo.toml` and then rerunning this command; a more detailed transition
-guide can be found at
-
-  https://doc.rust-lang.org/edition-guide/editions/transitioning-an-existing-project-to-a-new-edition.html
-",
-                    idioms,
-                    file,
-                    match edition {
-                        Some(s) => format!("with the {} edition", s),
-                        None => "without an edition".to_string(),
-                    },
-                ))?;
-                Ok(())
-            }
         }
     }
 }

From 820537c70643557a6376863d52911318a9770111 Mon Sep 17 00:00:00 2001
From: Eric Huss <eric@huss.org>
Date: Wed, 17 Feb 2021 20:41:38 -0800
Subject: [PATCH 02/11] Change Fixing to Fixed, and add a verbose "Fixing".

What was previously "Fixing" was a message for after the fixes had
been applied. I think it would be clearer if it said "Fixed",
to indicate that the fixes had actually finished.

The new "Fixing" is posted just before it starts. This is verbose-only
since it is a little noisy.
---
 crates/cargo-test-support/src/lib.rs |  1 +
 src/cargo/ops/fix.rs                 |  9 +++-
 src/cargo/util/diagnostic_server.rs  | 11 ++++-
 tests/testsuite/fix.rs               | 72 ++++++++++++++--------------
 tests/testsuite/glob_targets.rs      |  4 ++
 5 files changed, 58 insertions(+), 39 deletions(-)

diff --git a/crates/cargo-test-support/src/lib.rs b/crates/cargo-test-support/src/lib.rs
index fbaa9dd0d9b..b23561ad72d 100644
--- a/crates/cargo-test-support/src/lib.rs
+++ b/crates/cargo-test-support/src/lib.rs
@@ -1524,6 +1524,7 @@ fn substitute_macros(input: &str) -> String {
         ("[REPLACING]", "   Replacing"),
         ("[UNPACKING]", "   Unpacking"),
         ("[SUMMARY]", "     Summary"),
+        ("[FIXED]", "       Fixed"),
         ("[FIXING]", "      Fixing"),
         ("[EXE]", env::consts::EXE_SUFFIX),
         ("[IGNORED]", "     Ignored"),
diff --git a/src/cargo/ops/fix.rs b/src/cargo/ops/fix.rs
index 0ba8b41c6b4..78e29ab8126 100644
--- a/src/cargo/ops/fix.rs
+++ b/src/cargo/ops/fix.rs
@@ -238,7 +238,7 @@ pub fn fix_maybe_exec_rustc() -> CargoResult<bool> {
 
         if output.status.success() {
             for (path, file) in fixes.files.iter() {
-                Message::Fixing {
+                Message::Fixed {
                     file: path.clone(),
                     fixes: file.fixes_applied,
                 }
@@ -695,7 +695,12 @@ impl FixArgs {
     fn verify_not_preparing_for_enabled_edition(&self) -> CargoResult<()> {
         let edition = match self.prepare_for_edition {
             Some(s) => s,
-            None => return Ok(()),
+            None => {
+                return Message::Fixing {
+                    file: self.file.display().to_string(),
+                }
+                .post();
+            }
         };
         let enabled = match self.enabled_edition {
             Some(s) => s,
diff --git a/src/cargo/util/diagnostic_server.rs b/src/cargo/util/diagnostic_server.rs
index dd75e1c185f..dba68c08ad9 100644
--- a/src/cargo/util/diagnostic_server.rs
+++ b/src/cargo/util/diagnostic_server.rs
@@ -33,6 +33,9 @@ const PLEASE_REPORT_THIS_BUG: &str =
 pub enum Message {
     Fixing {
         file: String,
+    },
+    Fixed {
+        file: String,
         fixes: u32,
     },
     FixFailed {
@@ -89,10 +92,14 @@ impl<'a> DiagnosticPrinter<'a> {
 
     pub fn print(&mut self, msg: &Message) -> CargoResult<()> {
         match msg {
-            Message::Fixing { file, fixes } => {
+            Message::Fixing { file } => self
+                .config
+                .shell()
+                .verbose(|shell| shell.status("Fixing", file)),
+            Message::Fixed { file, fixes } => {
                 let msg = if *fixes == 1 { "fix" } else { "fixes" };
                 let msg = format!("{} ({} {})", file, fixes, msg);
-                self.config.shell().status("Fixing", msg)
+                self.config.shell().status("Fixed", msg)
             }
             Message::ReplaceFailed { file, message } => {
                 let msg = format!("error applying suggestions to `{}`\n", file);
diff --git a/tests/testsuite/fix.rs b/tests/testsuite/fix.rs
index cbb70ad2260..c87f957e128 100644
--- a/tests/testsuite/fix.rs
+++ b/tests/testsuite/fix.rs
@@ -1,8 +1,9 @@
 //! Tests for the `cargo fix` command.
 
+use cargo::core::Edition;
 use cargo_test_support::git;
 use cargo_test_support::paths;
-use cargo_test_support::{basic_manifest, project};
+use cargo_test_support::{basic_manifest, is_nightly, project};
 
 #[cargo_test]
 fn do_not_fix_broken_builds() {
@@ -161,7 +162,7 @@ fn broken_fixes_backed_out() {
         )
         .with_stderr_contains("Original diagnostics will follow.")
         .with_stderr_contains("[WARNING] variable does not need to be mutable")
-        .with_stderr_does_not_contain("[..][FIXING][..]")
+        .with_stderr_does_not_contain("[..][FIXED][..]")
         .run();
 
     // Make sure the fix which should have been applied was backed out
@@ -213,9 +214,9 @@ fn fix_path_deps() {
         .with_stderr_unordered(
             "\
 [CHECKING] bar v0.1.0 ([..])
-[FIXING] bar/src/lib.rs (1 fix)
+[FIXED] bar/src/lib.rs (1 fix)
 [CHECKING] foo v0.1.0 ([..])
-[FIXING] src/lib.rs (1 fix)
+[FIXED] src/lib.rs (1 fix)
 [FINISHED] [..]
 ",
         )
@@ -285,7 +286,7 @@ fn prepare_for_2018() {
 
     let stderr = "\
 [CHECKING] foo v0.0.1 ([..])
-[FIXING] src/lib.rs (2 fixes)
+[FIXED] src/lib.rs (2 fixes)
 [FINISHED] [..]
 ";
     p.cargo("fix --edition --allow-no-vcs")
@@ -319,14 +320,14 @@ fn local_paths() {
         )
         .build();
 
-    let stderr = "\
+    p.cargo("fix --edition --allow-no-vcs")
+        .with_stderr(
+            "\
 [CHECKING] foo v0.0.1 ([..])
-[FIXING] src/lib.rs (1 fix)
+[FIXED] src/lib.rs (1 fix)
 [FINISHED] [..]
-";
-
-    p.cargo("fix --edition --allow-no-vcs")
-        .with_stderr(stderr)
+",
+        )
         .with_stdout("")
         .run();
 
@@ -372,7 +373,7 @@ fn upgrade_extern_crate() {
     let stderr = "\
 [CHECKING] bar v0.1.0 ([..])
 [CHECKING] foo v0.1.0 ([..])
-[FIXING] src/lib.rs (1 fix)
+[FIXED] src/lib.rs (1 fix)
 [FINISHED] [..]
 ";
     p.cargo("fix --allow-no-vcs")
@@ -403,14 +404,15 @@ fn specify_rustflags() {
         )
         .build();
 
-    let stderr = "\
-[CHECKING] foo v0.0.1 ([..])
-[FIXING] src/lib.rs (1 fix)
-[FINISHED] [..]
-";
     p.cargo("fix --edition --allow-no-vcs")
         .env("RUSTFLAGS", "-C linker=cc")
-        .with_stderr(stderr)
+        .with_stderr(
+            "\
+[CHECKING] foo v0.0.1 ([..])
+[FIXED] src/lib.rs (1 fix)
+[FINISHED] [..]
+",
+        )
         .with_stdout("")
         .run();
 }
@@ -445,7 +447,7 @@ fn fixes_extra_mut() {
 
     let stderr = "\
 [CHECKING] foo v0.0.1 ([..])
-[FIXING] src/lib.rs (1 fix)
+[FIXED] src/lib.rs (1 fix)
 [FINISHED] [..]
 ";
     p.cargo("fix --allow-no-vcs")
@@ -472,7 +474,7 @@ fn fixes_two_missing_ampersands() {
 
     let stderr = "\
 [CHECKING] foo v0.0.1 ([..])
-[FIXING] src/lib.rs (2 fixes)
+[FIXED] src/lib.rs (2 fixes)
 [FINISHED] [..]
 ";
     p.cargo("fix --allow-no-vcs")
@@ -498,7 +500,7 @@ fn tricky() {
 
     let stderr = "\
 [CHECKING] foo v0.0.1 ([..])
-[FIXING] src/lib.rs (2 fixes)
+[FIXED] src/lib.rs (2 fixes)
 [FINISHED] [..]
 ";
     p.cargo("fix --allow-no-vcs")
@@ -594,8 +596,8 @@ fn fix_two_files() {
 
     p.cargo("fix --allow-no-vcs")
         .env("__CARGO_FIX_YOLO", "1")
-        .with_stderr_contains("[FIXING] src/bar.rs (1 fix)")
-        .with_stderr_contains("[FIXING] src/lib.rs (1 fix)")
+        .with_stderr_contains("[FIXED] src/bar.rs (1 fix)")
+        .with_stderr_contains("[FIXED] src/lib.rs (1 fix)")
         .run();
     assert!(!p.read_file("src/lib.rs").contains("let mut x = 3;"));
     assert!(!p.read_file("src/bar.rs").contains("let mut x = 3;"));
@@ -629,16 +631,16 @@ fn fixes_missing_ampersand() {
         .env("__CARGO_FIX_YOLO", "1")
         .with_stdout("")
         .with_stderr_contains("[COMPILING] foo v0.0.1 ([..])")
-        .with_stderr_contains("[FIXING] build.rs (1 fix)")
+        .with_stderr_contains("[FIXED] build.rs (1 fix)")
         // Don't assert number of fixes for this one, as we don't know if we're
         // fixing it once or twice! We run this all concurrently, and if we
         // compile (and fix) in `--test` mode first, we get two fixes. Otherwise
         // we'll fix one non-test thing, and then fix another one later in
         // test mode.
-        .with_stderr_contains("[FIXING] src/lib.rs[..]")
-        .with_stderr_contains("[FIXING] src/main.rs (1 fix)")
-        .with_stderr_contains("[FIXING] examples/foo.rs (1 fix)")
-        .with_stderr_contains("[FIXING] tests/a.rs (1 fix)")
+        .with_stderr_contains("[FIXED] src/lib.rs[..]")
+        .with_stderr_contains("[FIXED] src/main.rs (1 fix)")
+        .with_stderr_contains("[FIXED] examples/foo.rs (1 fix)")
+        .with_stderr_contains("[FIXED] tests/a.rs (1 fix)")
         .with_stderr_contains("[FINISHED] [..]")
         .run();
     p.cargo("build").run();
@@ -836,14 +838,14 @@ fn fix_overlapping() {
         )
         .build();
 
-    let stderr = "\
+    p.cargo("fix --allow-no-vcs --prepare-for 2018 --lib")
+        .with_stderr(
+            "\
 [CHECKING] foo [..]
-[FIXING] src/lib.rs (2 fixes)
+[FIXED] src/lib.rs (2 fixes)
 [FINISHED] dev [..]
-";
-
-    p.cargo("fix --allow-no-vcs --prepare-for 2018 --lib")
-        .with_stderr(stderr)
+",
+        )
         .run();
 
     let contents = p.read_file("src/lib.rs");
@@ -876,7 +878,7 @@ fn fix_idioms() {
 
     let stderr = "\
 [CHECKING] foo [..]
-[FIXING] src/lib.rs (1 fix)
+[FIXED] src/lib.rs (1 fix)
 [FINISHED] [..]
 ";
     p.cargo("fix --edition-idioms --allow-no-vcs")
diff --git a/tests/testsuite/glob_targets.rs b/tests/testsuite/glob_targets.rs
index a2dc4fdff49..643572e42a9 100644
--- a/tests/testsuite/glob_targets.rs
+++ b/tests/testsuite/glob_targets.rs
@@ -150,6 +150,7 @@ fn fix_example() {
             "\
 [CHECKING] foo v0.0.1 ([CWD])
 [RUNNING] `[..] rustc --crate-name example1 [..]`
+[FIXING] examples/example1.rs
 [FINISHED] dev [unoptimized + debuginfo] target(s) in [..]
 ",
         )
@@ -164,6 +165,7 @@ fn fix_bin() {
             "\
 [CHECKING] foo v0.0.1 ([CWD])
 [RUNNING] `[..] rustc --crate-name bin1 [..]`
+[FIXING] src/bin/bin1.rs
 [FINISHED] dev [unoptimized + debuginfo] target(s) in [..]
 ",
         )
@@ -178,6 +180,7 @@ fn fix_bench() {
             "\
 [CHECKING] foo v0.0.1 ([CWD])
 [RUNNING] `[..] rustc --crate-name bench1 [..]`
+[FIXING] benches/bench1.rs
 [FINISHED] dev [unoptimized + debuginfo] target(s) in [..]
 ",
         )
@@ -192,6 +195,7 @@ fn fix_test() {
             "\
 [CHECKING] foo v0.0.1 ([CWD])
 [RUNNING] `[..] rustc --crate-name test1 [..]`
+[FIXING] tests/test1.rs
 [FINISHED] dev [unoptimized + debuginfo] target(s) in [..]
 ",
         )

From 3f2f7e30ff7aa2045010ac845d96f652f118ff3e Mon Sep 17 00:00:00 2001
From: Eric Huss <eric@huss.org>
Date: Wed, 17 Feb 2021 21:36:28 -0800
Subject: [PATCH 03/11] Add a migrating message for `cargo fix --edition`.

This helps indicate which edition you are moving from and to.
---
 crates/cargo-test-support/src/lib.rs |  1 +
 src/cargo/ops/fix.rs                 | 44 +++++++++++++---------------
 src/cargo/util/diagnostic_server.rs  | 18 ++++++++++++
 tests/testsuite/fix.rs               |  5 ++++
 4 files changed, 44 insertions(+), 24 deletions(-)

diff --git a/crates/cargo-test-support/src/lib.rs b/crates/cargo-test-support/src/lib.rs
index b23561ad72d..7b130f443af 100644
--- a/crates/cargo-test-support/src/lib.rs
+++ b/crates/cargo-test-support/src/lib.rs
@@ -1535,6 +1535,7 @@ fn substitute_macros(input: &str) -> String {
         ("[LOGOUT]", "      Logout"),
         ("[YANK]", "        Yank"),
         ("[OWNER]", "       Owner"),
+        ("[MIGRATING]", "   Migrating"),
     ];
     let mut result = input.to_owned();
     for &(pat, subst) in &macros {
diff --git a/src/cargo/ops/fix.rs b/src/cargo/ops/fix.rs
index 78e29ab8126..0b42f045b17 100644
--- a/src/cargo/ops/fix.rs
+++ b/src/cargo/ops/fix.rs
@@ -301,7 +301,7 @@ fn rustfix_crate(
     filename: &Path,
     args: &FixArgs,
 ) -> Result<FixedCrate, Error> {
-    args.verify_not_preparing_for_enabled_edition()?;
+    args.check_edition_and_send_status()?;
 
     // First up, we want to make sure that each crate is only checked by one
     // process at a time. If two invocations concurrently check a crate then
@@ -685,15 +685,10 @@ impl FixArgs {
         }
     }
 
-    /// Verifies that we're not both preparing for an enabled edition and enabling
-    /// the edition.
-    ///
-    /// This indicates that `cargo fix --prepare-for` is being executed out of
-    /// order with enabling the edition itself, meaning that we wouldn't
-    /// actually be able to fix anything! If it looks like this is happening
-    /// then yield an error to the user, indicating that this is happening.
-    fn verify_not_preparing_for_enabled_edition(&self) -> CargoResult<()> {
-        let edition = match self.prepare_for_edition {
+    /// Validates the edition, and sends a message indicating what is being
+    /// done.
+    fn check_edition_and_send_status(&self) -> CargoResult<()> {
+        let to_edition = match self.prepare_for_edition {
             Some(s) => s,
             None => {
                 return Message::Fixing {
@@ -702,20 +697,21 @@ impl FixArgs {
                 .post();
             }
         };
-        let enabled = match self.enabled_edition {
-            Some(s) => s,
-            None => return Ok(()),
-        };
-        if edition != enabled {
-            return Ok(());
-        }
-
-        Message::EditionAlreadyEnabled {
-            file: self.file.display().to_string(),
-            edition,
+        let from_edition = self.enabled_edition.unwrap_or(Edition::Edition2015);
+        if from_edition == to_edition {
+            Message::EditionAlreadyEnabled {
+                file: self.file.display().to_string(),
+                edition: to_edition,
+            }
+            .post()?;
+            process::exit(1);
+        } else {
+            Message::Migrating {
+                file: self.file.display().to_string(),
+                from_edition,
+                to_edition,
+            }
+            .post()
         }
-        .post()?;
-
-        process::exit(1);
     }
 }
diff --git a/src/cargo/util/diagnostic_server.rs b/src/cargo/util/diagnostic_server.rs
index dba68c08ad9..a28b5bbf227 100644
--- a/src/cargo/util/diagnostic_server.rs
+++ b/src/cargo/util/diagnostic_server.rs
@@ -31,6 +31,11 @@ const PLEASE_REPORT_THIS_BUG: &str =
 
 #[derive(Deserialize, Serialize, Hash, Eq, PartialEq, Clone)]
 pub enum Message {
+    Migrating {
+        file: String,
+        from_edition: Edition,
+        to_edition: Edition,
+    },
     Fixing {
         file: String,
     },
@@ -92,6 +97,19 @@ impl<'a> DiagnosticPrinter<'a> {
 
     pub fn print(&mut self, msg: &Message) -> CargoResult<()> {
         match msg {
+            Message::Migrating {
+                file,
+                from_edition,
+                to_edition,
+            } => {
+                if !self.dedupe.insert(msg.clone()) {
+                    return Ok(());
+                }
+                self.config.shell().status(
+                    "Migrating",
+                    &format!("{} from {} edition to {}", file, from_edition, to_edition),
+                )
+            }
             Message::Fixing { file } => self
                 .config
                 .shell()
diff --git a/tests/testsuite/fix.rs b/tests/testsuite/fix.rs
index c87f957e128..e598f051c09 100644
--- a/tests/testsuite/fix.rs
+++ b/tests/testsuite/fix.rs
@@ -286,6 +286,7 @@ fn prepare_for_2018() {
 
     let stderr = "\
 [CHECKING] foo v0.0.1 ([..])
+[MIGRATING] src/lib.rs from 2015 edition to 2018
 [FIXED] src/lib.rs (2 fixes)
 [FINISHED] [..]
 ";
@@ -324,6 +325,7 @@ fn local_paths() {
         .with_stderr(
             "\
 [CHECKING] foo v0.0.1 ([..])
+[MIGRATING] src/lib.rs from 2015 edition to 2018
 [FIXED] src/lib.rs (1 fix)
 [FINISHED] [..]
 ",
@@ -409,6 +411,7 @@ fn specify_rustflags() {
         .with_stderr(
             "\
 [CHECKING] foo v0.0.1 ([..])
+[MIGRATING] src/lib.rs from 2015 edition to 2018
 [FIXED] src/lib.rs (1 fix)
 [FINISHED] [..]
 ",
@@ -842,6 +845,7 @@ fn fix_overlapping() {
         .with_stderr(
             "\
 [CHECKING] foo [..]
+[MIGRATING] src/lib.rs from 2015 edition to 2018
 [FIXED] src/lib.rs (2 fixes)
 [FINISHED] dev [..]
 ",
@@ -1164,6 +1168,7 @@ fn only_warn_for_relevant_crates() {
             "\
 [CHECKING] a v0.1.0 ([..])
 [CHECKING] foo v0.1.0 ([..])
+[MIGRATING] src/lib.rs from 2015 edition to 2018
 [FINISHED] dev [unoptimized + debuginfo] target(s) in [..]
 ",
         )

From 2ae72ff747285b02a68a4ed4f983ff9425d624f0 Mon Sep 17 00:00:00 2001
From: Eric Huss <eric@huss.org>
Date: Wed, 17 Feb 2021 22:01:42 -0800
Subject: [PATCH 04/11] Add edition2021 cargo feature.

This is intended to help make it easier to test the 2021 edition.
---
 src/cargo/core/compiler/compilation.rs |  6 +-
 src/cargo/core/compiler/mod.rs         |  6 +-
 src/cargo/core/features.rs             | 32 ++++++++-
 src/cargo/util/toml/mod.rs             |  9 +++
 src/doc/src/reference/unstable.md      | 20 ++++++
 tests/testsuite/edition.rs             | 90 +++++++++++++++++++++++++-
 6 files changed, 153 insertions(+), 10 deletions(-)

diff --git a/src/cargo/core/compiler/compilation.rs b/src/cargo/core/compiler/compilation.rs
index ba4f0f8f576..fee774da4d2 100644
--- a/src/cargo/core/compiler/compilation.rs
+++ b/src/cargo/core/compiler/compilation.rs
@@ -8,7 +8,7 @@ use semver::Version;
 
 use super::BuildContext;
 use crate::core::compiler::{CompileKind, Metadata, Unit};
-use crate::core::{Edition, Package};
+use crate::core::Package;
 use crate::util::{self, config, join_paths, process, CargoResult, Config, ProcessBuilder};
 
 /// Structure with enough information to run `rustdoc --test`.
@@ -187,9 +187,7 @@ impl<'cfg> Compilation<'cfg> {
         let rustdoc = process(&*self.config.rustdoc()?);
         let cmd = fill_rustc_tool_env(rustdoc, unit);
         let mut p = self.fill_env(cmd, &unit.pkg, script_meta, unit.kind, true)?;
-        if unit.target.edition() != Edition::Edition2015 {
-            p.arg(format!("--edition={}", unit.target.edition()));
-        }
+        unit.target.edition().cmd_edition_arg(&mut p);
 
         for crate_type in unit.target.rustc_crate_types() {
             p.arg("--crate-type").arg(crate_type.as_str());
diff --git a/src/cargo/core/compiler/mod.rs b/src/cargo/core/compiler/mod.rs
index b9c3a15c581..7830bc1e6e0 100644
--- a/src/cargo/core/compiler/mod.rs
+++ b/src/cargo/core/compiler/mod.rs
@@ -52,7 +52,7 @@ pub use crate::core::compiler::unit::{Unit, UnitInterner};
 use crate::core::features::nightly_features_allowed;
 use crate::core::manifest::TargetSourcePath;
 use crate::core::profiles::{PanicStrategy, Profile, Strip};
-use crate::core::{Edition, Feature, PackageId, Target};
+use crate::core::{Feature, PackageId, Target};
 use crate::util::errors::{self, CargoResult, CargoResultExt, ProcessError, VerboseError};
 use crate::util::interning::InternedString;
 use crate::util::machine_message::Message;
@@ -782,9 +782,7 @@ fn build_base_args(
     cmd.arg("--crate-name").arg(&unit.target.crate_name());
 
     let edition = unit.target.edition();
-    if edition != Edition::Edition2015 {
-        cmd.arg(format!("--edition={}", edition));
-    }
+    edition.cmd_edition_arg(cmd);
 
     add_path_args(bcx, unit, cmd);
     add_error_format_and_color(cx, cmd, cx.rmeta_required(unit));
diff --git a/src/cargo/core/features.rs b/src/cargo/core/features.rs
index 494e3399300..3dcd48ceab8 100644
--- a/src/cargo/core/features.rs
+++ b/src/cargo/core/features.rs
@@ -101,7 +101,7 @@ use anyhow::{bail, Error};
 use serde::{Deserialize, Serialize};
 
 use crate::util::errors::CargoResult;
-use crate::util::indented_lines;
+use crate::util::{indented_lines, ProcessBuilder};
 
 pub const SEE_CHANNELS: &str =
     "See https://doc.rust-lang.org/book/appendix-07-nightly-rust.html for more information \
@@ -119,14 +119,41 @@ pub enum Edition {
 }
 
 impl Edition {
+    /// The latest edition (may or may not be stable).
+    pub const LATEST: Edition = Edition::Edition2021;
+
+    /// Returns the first version that a particular edition was released on
+    /// stable.
     pub(crate) fn first_version(&self) -> Option<semver::Version> {
         use Edition::*;
         match self {
             Edition2015 => None,
             Edition2018 => Some(semver::Version::new(1, 31, 0)),
+            // FIXME: This will likely be 1.56, update when that seems more likely.
             Edition2021 => Some(semver::Version::new(1, 62, 0)),
         }
     }
+
+    /// Returns `true` if this edition is stable in this release.
+    pub fn is_stable(&self) -> bool {
+        use Edition::*;
+        match self {
+            Edition2015 => true,
+            Edition2018 => true,
+            Edition2021 => false,
+        }
+    }
+
+    /// Updates the given [`ProcessBuilder`] to include the appropriate flags
+    /// for setting the edition.
+    pub(crate) fn cmd_edition_arg(&self, cmd: &mut ProcessBuilder) {
+        if *self != Edition::Edition2015 {
+            cmd.arg(format!("--edition={}", self));
+        }
+        if !self.is_stable() {
+            cmd.arg("-Z").arg("unstable-options");
+        }
+    }
 }
 
 impl fmt::Display for Edition {
@@ -282,6 +309,9 @@ features! {
 
     // Specifying a minimal 'rust-version' attribute for crates
     (unstable, rust_version, "", "reference/unstable.html#rust-version"),
+
+    // Support for 2021 edition.
+    (unstable, edition2021, "", "reference/unstable.html#edition-2021"),
 }
 
 const PUBLISH_LOCKFILE_REMOVED: &str = "The publish-lockfile key in Cargo.toml \
diff --git a/src/cargo/util/toml/mod.rs b/src/cargo/util/toml/mod.rs
index 6d6b9f1e76a..683f5e7c825 100644
--- a/src/cargo/util/toml/mod.rs
+++ b/src/cargo/util/toml/mod.rs
@@ -1061,6 +1061,15 @@ impl TomlManifest {
         } else {
             Edition::Edition2015
         };
+        if edition == Edition::Edition2021 {
+            features.require(Feature::edition2021())?;
+        } else if !edition.is_stable() {
+            // Guard in case someone forgets to add .require()
+            return Err(util::errors::internal(format!(
+                "edition {} should be gated",
+                edition
+            )));
+        }
 
         let rust_version = if let Some(rust_version) = &project.rust_version {
             if features.require(Feature::rust_version()).is_err() {
diff --git a/src/doc/src/reference/unstable.md b/src/doc/src/reference/unstable.md
index 49ec4187350..c48fed762c4 100644
--- a/src/doc/src/reference/unstable.md
+++ b/src/doc/src/reference/unstable.md
@@ -1064,6 +1064,26 @@ version = "0.0.1"
 rust-version = "1.42"
 ```
 
+### edition 2021
+
+Support for the 2021 [edition] can be enabled by adding the `edition2021`
+unstable feature to the top of `Cargo.toml`:
+
+```toml
+cargo-features = ["edition2021"]
+
+[package]
+name = "my-package"
+version = "0.1.0"
+edition = "2021"
+```
+
+This feature is very unstable, and is only intended for early testing and
+experimentation. Future nightly releases may introduce changes for the 2021
+edition that may break your build.
+
+[edition]: ../../edition-guide/index.html
+
 <script>
 (function() {
     var fragments = {
diff --git a/tests/testsuite/edition.rs b/tests/testsuite/edition.rs
index 184b9b3cd0f..c675fdbb98b 100644
--- a/tests/testsuite/edition.rs
+++ b/tests/testsuite/edition.rs
@@ -1,6 +1,7 @@
 //! Tests for edition setting.
 
-use cargo_test_support::{basic_lib_manifest, project};
+use cargo::core::Edition;
+use cargo_test_support::{basic_lib_manifest, is_nightly, project};
 
 #[cargo_test]
 fn edition_works_for_build_script() {
@@ -32,3 +33,90 @@ fn edition_works_for_build_script() {
 
     p.cargo("build -v").run();
 }
+
+#[cargo_test]
+fn edition_unstable_gated() {
+    // During the period where a new edition is coming up, but not yet stable,
+    // this test will verify that it cannot be used on stable. If there is no
+    // next edition, it does nothing.
+    let next = Edition::LATEST;
+    if next.is_stable() {
+        eprintln!("Next edition is currently not available, skipping test.");
+        return;
+    }
+    let p = project()
+        .file(
+            "Cargo.toml",
+            &format!(
+                r#"
+                [package]
+                name = "foo"
+                version = "0.1.0"
+                edition = "{}"
+            "#,
+                next
+            ),
+        )
+        .file("src/lib.rs", "")
+        .build();
+
+    p.cargo("check")
+        .with_status(101)
+        .with_stderr(&format!(
+            "\
+[ERROR] failed to parse manifest at `[..]/foo/Cargo.toml`
+
+Caused by:
+  feature `edition{next}` is required
+
+  this Cargo does not support nightly features, but if you
+  switch to nightly channel you can add
+  `cargo-features = [\"edition{next}\"]` to enable this feature
+",
+            next = next
+        ))
+        .run();
+}
+
+#[cargo_test]
+fn edition_unstable() {
+    // During the period where a new edition is coming up, but not yet stable,
+    // this test will verify that it can be used with `cargo-features`. If
+    // there is no next edition, it does nothing.
+    if !is_nightly() {
+        // This test is fundamentally always nightly.
+        return;
+    }
+    let next = Edition::LATEST;
+    if next.is_stable() {
+        eprintln!("Next edition is currently not available, skipping test.");
+        return;
+    }
+    let p = project()
+        .file(
+            "Cargo.toml",
+            &format!(
+                r#"
+                cargo-features = ["edition{next}"]
+
+                [package]
+                name = "foo"
+                version = "0.1.0"
+                edition = "{next}"
+            "#,
+                next = next
+            ),
+        )
+        .file("src/lib.rs", "")
+        .build();
+
+    p.cargo("check")
+        .masquerade_as_nightly_cargo()
+        .with_stderr(
+            "\
+[CHECKING] foo [..]
+[FINISHED] [..]
+",
+        )
+        .run();
+}

From 37f4ff9a9a01ee5d62884cb8b17d2926641e8275 Mon Sep 17 00:00:00 2001
From: Eric Huss <eric@huss.org>
Date: Wed, 17 Feb 2021 22:06:58 -0800
Subject: [PATCH 05/11] Make "2" the default resolver in the 2021 edition.

---
 src/cargo/util/toml/mod.rs        |  8 +++-
 src/doc/src/reference/unstable.md |  3 ++
 tests/testsuite/features2.rs      | 74 +++++++++++++++++++++++++++++++
 3 files changed, 84 insertions(+), 1 deletion(-)

diff --git a/src/cargo/util/toml/mod.rs b/src/cargo/util/toml/mod.rs
index 683f5e7c825..fe7fcdb08ad 100644
--- a/src/cargo/util/toml/mod.rs
+++ b/src/cargo/util/toml/mod.rs
@@ -1132,7 +1132,13 @@ impl TomlManifest {
             project.resolver.as_ref(),
             me.workspace.as_ref().and_then(|ws| ws.resolver.as_ref()),
         ) {
-            (None, None) => None,
+            (None, None) => {
+                if edition == Edition::Edition2021 {
+                    Some(ResolveBehavior::V2)
+                } else {
+                    None
+                }
+            }
             (Some(s), None) | (None, Some(s)) => Some(ResolveBehavior::from_manifest(s)?),
             (Some(_), Some(_)) => {
                 bail!("cannot specify `resolver` field in both `[workspace]` and `[package]`")
diff --git a/src/doc/src/reference/unstable.md b/src/doc/src/reference/unstable.md
index c48fed762c4..ae84a1988a9 100644
--- a/src/doc/src/reference/unstable.md
+++ b/src/doc/src/reference/unstable.md
@@ -1082,7 +1082,10 @@ This feature is very unstable, and is only intended for early testing and
 experimentation. Future nightly releases may introduce changes for the 2021
 edition that may break your build.
 
+The 2021 edition will set the default [resolver version] to "2".
+
 [edition]: ../../edition-guide/index.html
+[resolver version]: resolver.md#resolver-versions
 
 <script>
 (function() {
diff --git a/tests/testsuite/features2.rs b/tests/testsuite/features2.rs
index d581b4947bd..0d6c082b04c 100644
--- a/tests/testsuite/features2.rs
+++ b/tests/testsuite/features2.rs
@@ -2324,3 +2324,77 @@ fn doc_proc_macro() {
     // so rustdoc can load it).
     p.cargo("doc").run();
 }
+
+#[cargo_test]
+fn edition_2021_default_2() {
+    // edition = 2021 defaults to v2 resolver.
+    Package::new("common", "1.0.0")
+        .feature("f1", &[])
+        .file("src/lib.rs", "")
+        .publish();
+
+    Package::new("bar", "1.0.0")
+        .add_dep(
+            Dependency::new("common", "1.0")
+                .target("cfg(whatever)")
+                .enable_features(&["f1"]),
+        )
+        .publish();
+
+    let p = project()
+        .file(
+            "Cargo.toml",
+            r#"
+                [package]
+                name = "foo"
+                version = "0.1.0"
+
+                [dependencies]
+                common = "1.0"
+                bar = "1.0"
+            "#,
+        )
+        .file("src/lib.rs", "")
+        .build();
+
+    // First without edition.
+    p.cargo("tree -f")
+        .arg("{p} feats:{f}")
+        .with_stdout(
+            "\
+foo v0.1.0 [..]
+├── bar v1.0.0 feats:
+└── common v1.0.0 feats:f1
+",
+        )
+        .run();
+
+    p.change_file(
+        "Cargo.toml",
+        r#"
+            cargo-features = ["edition2021"]
+
+            [package]
+            name = "foo"
+            version = "0.1.0"
+            edition = "2021"
+
+            [dependencies]
+            common = "1.0"
+            bar = "1.0"
+        "#,
+    );
+
+    // Importantly, this does not include `f1` on `common`.
+    p.cargo("tree -f")
+        .arg("{p} feats:{f}")
+        .masquerade_as_nightly_cargo()
+        .with_stdout(
+            "\
+foo v0.1.0 [..]
+├── bar v1.0.0 feats:
+└── common v1.0.0 feats:
+",
+        )
+        .run();
+}

From 28850225a1b080c75c2110c2e8a13748c6ce4c52 Mon Sep 17 00:00:00 2001
From: Eric Huss <eric@huss.org>
Date: Wed, 17 Feb 2021 22:12:46 -0800
Subject: [PATCH 06/11] Updates to `cargo fix --edition`.

* `--edition` always means "next" edition.
* `--edition` when on the most recent edition is not an error, just a warning.
* Support fix to 2021 edition.
---
 src/cargo/core/features.rs          |  26 +++++
 src/cargo/ops/fix.rs                |  30 ++++-
 src/cargo/util/diagnostic_server.rs |  22 +---
 src/doc/src/reference/unstable.md   |   4 +
 tests/testsuite/fix.rs              | 174 +++++++++++++++++++++++++---
 5 files changed, 219 insertions(+), 37 deletions(-)

diff --git a/src/cargo/core/features.rs b/src/cargo/core/features.rs
index 3dcd48ceab8..4419ff4ff7e 100644
--- a/src/cargo/core/features.rs
+++ b/src/cargo/core/features.rs
@@ -144,6 +144,18 @@ impl Edition {
         }
     }
 
+    /// Returns the previous edition from this edition.
+    ///
+    /// Returns `None` for 2015.
+    pub fn previous(&self) -> Option<Edition> {
+        use Edition::*;
+        match self {
+            Edition2015 => None,
+            Edition2018 => Some(Edition2015),
+            Edition2021 => Some(Edition2018),
+        }
+    }
+
     /// Updates the given [`ProcessBuilder`] to include the appropriate flags
     /// for setting the edition.
     pub(crate) fn cmd_edition_arg(&self, cmd: &mut ProcessBuilder) {
@@ -154,6 +166,20 @@ impl Edition {
             cmd.arg("-Z").arg("unstable-options");
         }
     }
+
+    /// Whether or not this edition supports the `rust_*_compatibility` lint.
+    ///
+    /// Ideally this would not be necessary, but currently 2021 does not have
+    /// any lints, and thus `rustc` doesn't recognize it. Perhaps `rustc`
+    /// could create an empty group instead?
+    pub(crate) fn supports_compat_lint(&self) -> bool {
+        use Edition::*;
+        match self {
+            Edition2015 => false,
+            Edition2018 => true,
+            Edition2021 => false,
+        }
+    }
 }
 
 impl fmt::Display for Edition {
diff --git a/src/cargo/ops/fix.rs b/src/cargo/ops/fix.rs
index 0b42f045b17..4e6d611da06 100644
--- a/src/cargo/ops/fix.rs
+++ b/src/cargo/ops/fix.rs
@@ -50,7 +50,7 @@ use log::{debug, trace, warn};
 use rustfix::diagnostics::Diagnostic;
 use rustfix::{self, CodeFix};
 
-use crate::core::{Edition, Workspace};
+use crate::core::{nightly_features_allowed, Edition, Workspace};
 use crate::ops::{self, CompileOptions};
 use crate::util::diagnostic_server::{Message, RustfixDiagnosticServer};
 use crate::util::errors::CargoResult;
@@ -652,7 +652,7 @@ impl FixArgs {
         } else if env::var(EDITION_ENV).is_ok() {
             match enabled_edition {
                 None | Some(Edition::Edition2015) => Some(Edition::Edition2018),
-                Some(Edition::Edition2018) => Some(Edition::Edition2018), // TODO: Change to 2021 when rustc is ready for it.
+                Some(Edition::Edition2018) => Some(Edition::Edition2021),
                 Some(Edition::Edition2021) => Some(Edition::Edition2021),
             }
         } else {
@@ -681,7 +681,9 @@ impl FixArgs {
         }
 
         if let Some(edition) = self.prepare_for_edition {
-            cmd.arg("-W").arg(format!("rust-{}-compatibility", edition));
+            if edition.supports_compat_lint() {
+                cmd.arg("-W").arg(format!("rust-{}-compatibility", edition));
+            }
         }
     }
 
@@ -697,14 +699,32 @@ impl FixArgs {
                 .post();
             }
         };
+        // Unfortunately determining which cargo targets are being built
+        // isn't easy, and each target can be a different edition. The
+        // cargo-as-rustc fix wrapper doesn't know anything about the
+        // workspace, so it can't check for the `cargo-features` unstable
+        // opt-in. As a compromise, this just restricts to the nightly
+        // toolchain.
+        //
+        // Unfortunately this results in a pretty poor error message when
+        // multiple jobs run in parallel (the error appears multiple
+        // times). Hopefully this doesn't happen often in practice.
+        if !to_edition.is_stable() && !nightly_features_allowed() {
+            bail!(
+                "cannot migrate {} to edition {to_edition}\n\
+                 Edition {to_edition} is unstable and not allowed in this release, \
+                 consider trying the nightly release channel.",
+                self.file.display(),
+                to_edition = to_edition
+            );
+        }
         let from_edition = self.enabled_edition.unwrap_or(Edition::Edition2015);
         if from_edition == to_edition {
             Message::EditionAlreadyEnabled {
                 file: self.file.display().to_string(),
                 edition: to_edition,
             }
-            .post()?;
-            process::exit(1);
+            .post()
         } else {
             Message::Migrating {
                 file: self.file.display().to_string(),
diff --git a/src/cargo/util/diagnostic_server.rs b/src/cargo/util/diagnostic_server.rs
index a28b5bbf227..1fedf621cba 100644
--- a/src/cargo/util/diagnostic_server.rs
+++ b/src/cargo/util/diagnostic_server.rs
@@ -180,24 +180,10 @@ impl<'a> DiagnosticPrinter<'a> {
                 if !self.dedupe.insert(msg.clone()) {
                     return Ok(());
                 }
-
-                let msg = format!(
-                    "\
-cannot prepare for the {} edition when it is enabled, so cargo cannot
-automatically fix errors in `{}`
-
-To prepare for the {0} edition you should first remove `edition = '{0}'` from
-your `Cargo.toml` and then rerun this command. Once all warnings have been fixed
-then you can re-enable the `edition` key in `Cargo.toml`. For some more
-information about transitioning to the {0} edition see:
-
-  https://doc.rust-lang.org/edition-guide/editions/transitioning-an-existing-project-to-a-new-edition.html
-",
-                    edition,
-                    file,
-                );
-                self.config.shell().error(&msg)?;
-                Ok(())
+                self.config.shell().warn(&format!(
+                    "`{}` is already on the latest edition ({}), unable to migrate further",
+                    file, edition
+                ))
             }
         }
     }
diff --git a/src/doc/src/reference/unstable.md b/src/doc/src/reference/unstable.md
index ae84a1988a9..fb248427a68 100644
--- a/src/doc/src/reference/unstable.md
+++ b/src/doc/src/reference/unstable.md
@@ -1078,6 +1078,10 @@ version = "0.1.0"
 edition = "2021"
 ```
 
+If you want to transition an existing project from a previous edition, then
+`cargo fix --edition` can be used on the nightly channel. After running `cargo
+fix`, you can switch the edition to 2021 as illustrated above.
+
 This feature is very unstable, and is only intended for early testing and
 experimentation. Future nightly releases may introduce changes for the 2021
 edition that may break your build.
diff --git a/tests/testsuite/fix.rs b/tests/testsuite/fix.rs
index e598f051c09..b76fda4b141 100644
--- a/tests/testsuite/fix.rs
+++ b/tests/testsuite/fix.rs
@@ -791,35 +791,181 @@ fn fix_all_targets_by_default() {
 }
 
 #[cargo_test]
-fn prepare_for_and_enable() {
+fn prepare_for_unstable() {
+    // During the period where a new edition is coming up, but not yet stable,
+    // this test will verify that it cannot be migrated to on stable. If there
+    // is no next edition, it does nothing.
+    let next = Edition::LATEST;
+    if next.is_stable() {
+        eprintln!("Next edition is currently not available, skipping test.");
+        return;
+    }
+    let latest_stable = next.previous().unwrap();
     let p = project()
         .file(
             "Cargo.toml",
-            r#"
+            &format!(
+                r#"
+                [package]
+                name = "foo"
+                version = "0.1.0"
+                edition = "{}"
+            "#,
+                latest_stable
+            ),
+        )
+        .file("src/lib.rs", "")
+        .build();
+
+    // -j1 to make the error more deterministic (otherwise there can be
+    // multiple errors since they run in parallel).
+    p.cargo("fix --edition --allow-no-vcs -j1")
+        .with_status(101)
+        .with_stderr(&format!("\
+[CHECKING] foo [..]
+[ERROR] cannot migrate src/lib.rs to edition {next}
+Edition {next} is unstable and not allowed in this release, consider trying the nightly release channel.
+error: could not compile `foo`
+
+To learn more, run the command again with --verbose.
+", next=next))
+        .run();
+
+    if !is_nightly() {
+        // The rest of this test is fundamentally always nightly.
+        return;
+    }
+
+    p.cargo("fix --edition --allow-no-vcs")
+        .masquerade_as_nightly_cargo()
+        .with_stderr(&format!(
+            "\
+[CHECKING] foo [..]
+[MIGRATING] src/lib.rs from {latest_stable} edition to {next}
+[FINISHED] [..]
+",
+            latest_stable = latest_stable,
+            next = next,
+        ))
+        .run();
+}
+
+#[cargo_test]
+fn prepare_for_latest_stable() {
+    // This is the stable counterpart of prepare_for_unstable.
+    let latest = Edition::LATEST;
+    let latest_stable = if latest.is_stable() {
+        latest
+    } else {
+        latest.previous().unwrap()
+    };
+    let previous = latest_stable.previous().unwrap();
+    let p = project()
+        .file(
+            "Cargo.toml",
+            &format!(
+                r#"
                 [package]
                 name = 'foo'
                 version = '0.1.0'
-                edition = '2018'
+                edition = '{}'
             "#,
+                previous
+            ),
         )
         .file("src/lib.rs", "")
         .build();
 
-    let stderr = "\
-error: cannot prepare for the 2018 edition when it is enabled, so cargo cannot
-automatically fix errors in `src/lib.rs`
+    p.cargo("fix --edition --allow-no-vcs")
+        .with_stderr(&format!(
+            "\
+[CHECKING] foo [..]
+[MIGRATING] src/lib.rs from {} edition to {}
+[FINISHED] [..]
+",
+            previous, latest_stable
+        ))
+        .run();
+}
 
-To prepare for the 2018 edition you should first remove `edition = '2018'` from
-your `Cargo.toml` and then rerun this command. Once all warnings have been fixed
-then you can re-enable the `edition` key in `Cargo.toml`. For some more
-information about transitioning to the 2018 edition see:
+#[cargo_test]
+fn prepare_for_already_on_latest_unstable() {
+    // During the period where a new edition is coming up, but not yet stable,
+    // this test will check what happens if you are already on the latest. If
+    // there is no next edition, it does nothing.
+    if !is_nightly() {
+        // This test is fundamentally always nightly.
+        return;
+    }
+    let next_edition = Edition::LATEST;
+    if next_edition.is_stable() {
+        eprintln!("Next edition is currently not available, skipping test.");
+        return;
+    }
+    let p = project()
+        .file(
+            "Cargo.toml",
+            &format!(
+                r#"
+                cargo-features = ["edition{}"]
 
-  https://[..]
+                [package]
+                name = 'foo'
+                version = '0.1.0'
+                edition = '{}'
+            "#,
+                next_edition, next_edition
+            ),
+        )
+        .file("src/lib.rs", "")
+        .build();
 
-";
     p.cargo("fix --edition --allow-no-vcs")
-        .with_stderr_contains(stderr)
-        .with_status(101)
+        .masquerade_as_nightly_cargo()
+        .with_stderr_contains(&format!(
+            "\
+[CHECKING] foo [..]
+[WARNING] `src/lib.rs` is already on the latest edition ({next_edition}), unable to migrate further
+[FINISHED] [..]
+",
+            next_edition = next_edition
+        ))
+        .run();
+}
+
+#[cargo_test]
+fn prepare_for_already_on_latest_stable() {
+    // Stable counterpart of prepare_for_already_on_latest_unstable.
+    if !Edition::LATEST.is_stable() {
+        eprintln!("This test cannot run while the latest edition is unstable, skipping.");
+        return;
+    }
+    let latest_stable = Edition::LATEST;
+    let p = project()
+        .file(
+            "Cargo.toml",
+            &format!(
+                r#"
+                [package]
+                name = 'foo'
+                version = '0.1.0'
+                edition = '{}'
+            "#,
+                latest_stable
+            ),
+        )
+        .file("src/lib.rs", "")
+        .build();
+
+    p.cargo("fix --edition --allow-no-vcs")
+        .with_stderr_contains(&format!(
+            "\
+[CHECKING] foo [..]
+[WARNING] `src/lib.rs` is already on the latest edition ({latest_stable}), unable to migrate further
+[FINISHED] [..]
+",
+            latest_stable = latest_stable
+        ))
         .run();
 }
 

From 21cfac6c09d0a5a6a37854f443c752a012ecf2a7 Mon Sep 17 00:00:00 2001
From: Eric Huss <eric@huss.org>
Date: Wed, 17 Feb 2021 22:14:35 -0800
Subject: [PATCH 07/11] Update `cargo fix --edition` docs.

# Conflicts:
#	src/cargo/ops/fix.rs
#	src/doc/src/reference/unstable.md
---
 src/doc/man/cargo-fix.md                | 38 +++++++++++++++-------
 src/doc/man/generated_txt/cargo-fix.txt | 42 ++++++++++++++++++-------
 src/doc/src/commands/cargo-fix.md       | 38 +++++++++++++++-------
 src/etc/man/cargo-fix.1                 | 41 +++++++++++++++++-------
 4 files changed, 111 insertions(+), 48 deletions(-)

diff --git a/src/doc/man/cargo-fix.md b/src/doc/man/cargo-fix.md
index 606fe1acd62..7e95a0eafc8 100644
--- a/src/doc/man/cargo-fix.md
+++ b/src/doc/man/cargo-fix.md
@@ -14,17 +14,13 @@ cargo-fix - Automatically fix lint warnings reported by rustc
 This Cargo subcommand will automatically take rustc's suggestions from
 diagnostics like warnings and apply them to your source code. This is intended
 to help automate tasks that rustc itself already knows how to tell you to fix!
-The `cargo fix` subcommand is also being developed for the Rust 2018 edition
-to provide code the ability to easily opt-in to the new edition without having
-to worry about any breakage.
 
 Executing `cargo fix` will under the hood execute {{man "cargo-check" 1}}. Any warnings
 applicable to your crate will be automatically fixed (if possible) and all
 remaining warnings will be displayed when the check process is finished. For
-example if you'd like to prepare for the 2018 edition, you can do so by
-executing:
+example if you'd like to apply all fixes to the current package, you can run:
 
-    cargo fix --edition
+    cargo fix
 
 which behaves the same as `cargo check --all-targets`.
 
@@ -32,16 +28,34 @@ which behaves the same as `cargo check --all-targets`.
 `cargo check`. If code is conditionally enabled with optional features, you
 will need to enable those features for that code to be analyzed:
 
-    cargo fix --edition --features foo
+    cargo fix --features foo
 
 Similarly, other `cfg` expressions like platform-specific code will need to
 pass `--target` to fix code for the given target.
 
-    cargo fix --edition --target x86_64-pc-windows-gnu
+    cargo fix --target x86_64-pc-windows-gnu
 
 If you encounter any problems with `cargo fix` or otherwise have any questions
 or feature requests please don't hesitate to file an issue at
-<https://github.com/rust-lang/cargo>
+<https://github.com/rust-lang/cargo>.
+
+### Edition migration
+
+The `cargo fix` subcommand can also be used to migrate a package from one
+[edition] to the next. The general procedure is:
+
+1. Run `cargo fix --edition`
+2. Modify `Cargo.toml` to set the [edition field] to the new edition.
+3. Run your project tests to verify that everything still works.
+
+And hopefully that's it! Just keep in mind of the caveats mentioned above that
+`cargo fix` cannot update code for inactive features or `cfg` expressions.
+Also, in some rare cases the compiler is unable to automatically migrate all
+code to the new edition, and this may require manual changes after building
+with the new edition.
+
+[edition]: https://doc.rust-lang.org/edition-guide/editions/transitioning-an-existing-project-to-a-new-edition.html
+[edition field]: ../reference/manifest.html#the-edition-field
 
 ## OPTIONS
 
@@ -56,9 +70,9 @@ code in the working directory for you to inspect and manually fix.
 {{/option}}
 
 {{#option "`--edition`" }}
-Apply changes that will update the code to the latest edition. This will not
+Apply changes that will update the code to the next edition. This will not
 update the edition in the `Cargo.toml` manifest, which must be updated
-manually.
+manually after `cargo fix --edition` has finished.
 {{/option}}
 
 {{#option "`--edition-idioms`" }}
@@ -146,7 +160,7 @@ When no target selection options are given, `cargo fix` will fix all targets
 
        cargo fix
 
-2. Convert a 2015 edition to 2018:
+2. Update a package to prepare it for the next edition:
 
        cargo fix --edition
 
diff --git a/src/doc/man/generated_txt/cargo-fix.txt b/src/doc/man/generated_txt/cargo-fix.txt
index f0785699ea7..d74d796ac42 100644
--- a/src/doc/man/generated_txt/cargo-fix.txt
+++ b/src/doc/man/generated_txt/cargo-fix.txt
@@ -10,17 +10,15 @@ DESCRIPTION
        This Cargo subcommand will automatically take rustc's suggestions from
        diagnostics like warnings and apply them to your source code. This is
        intended to help automate tasks that rustc itself already knows how to
-       tell you to fix! The cargo fix subcommand is also being developed for
-       the Rust 2018 edition to provide code the ability to easily opt-in to
-       the new edition without having to worry about any breakage.
+       tell you to fix!
 
        Executing cargo fix will under the hood execute cargo-check(1). Any
        warnings applicable to your crate will be automatically fixed (if
        possible) and all remaining warnings will be displayed when the check
-       process is finished. For example if you'd like to prepare for the 2018
-       edition, you can do so by executing:
+       process is finished. For example if you'd like to apply all fixes to the
+       current package, you can run:
 
-           cargo fix --edition
+           cargo fix
 
        which behaves the same as cargo check --all-targets.
 
@@ -28,16 +26,36 @@ DESCRIPTION
        cargo check. If code is conditionally enabled with optional features,
        you will need to enable those features for that code to be analyzed:
 
-           cargo fix --edition --features foo
+           cargo fix --features foo
 
        Similarly, other cfg expressions like platform-specific code will need
        to pass --target to fix code for the given target.
 
-           cargo fix --edition --target x86_64-pc-windows-gnu
+           cargo fix --target x86_64-pc-windows-gnu
 
        If you encounter any problems with cargo fix or otherwise have any
        questions or feature requests please don't hesitate to file an issue at
-       <https://github.com/rust-lang/cargo>
+       <https://github.com/rust-lang/cargo>.
+
+   Edition migration
+       The cargo fix subcommand can also be used to migrate a package from one
+       edition
+       <https://doc.rust-lang.org/edition-guide/editions/transitioning-an-existing-project-to-a-new-edition.html>
+       to the next. The general procedure is:
+
+       1. Run cargo fix --edition
+
+       2. Modify Cargo.toml to set the edition field
+          <https://doc.rust-lang.org/cargo/reference/manifest.html#the-edition-field>
+          to the new edition.
+
+       3. Run your project tests to verify that everything still works.
+
+       And hopefully that's it! Just keep in mind of the caveats mentioned
+       above that cargo fix cannot update code for inactive features or cfg
+       expressions. Also, in some rare cases the compiler is unable to
+       automatically migrate all code to the new edition, and this may require
+       manual changes after building with the new edition.
 
 OPTIONS
    Fix options
@@ -48,9 +66,9 @@ OPTIONS
            and manually fix.
 
        --edition
-           Apply changes that will update the code to the latest edition. This
+           Apply changes that will update the code to the next edition. This
            will not update the edition in the Cargo.toml manifest, which must
-           be updated manually.
+           be updated manually after cargo fix --edition has finished.
 
        --edition-idioms
            Apply suggestions that will update code to the preferred style for
@@ -356,7 +374,7 @@ EXAMPLES
 
               cargo fix
 
-       2. Convert a 2015 edition to 2018:
+       2. Update a package to prepare it for the next edition:
 
               cargo fix --edition
 
diff --git a/src/doc/src/commands/cargo-fix.md b/src/doc/src/commands/cargo-fix.md
index eca6e68f0e0..4e9430e924d 100644
--- a/src/doc/src/commands/cargo-fix.md
+++ b/src/doc/src/commands/cargo-fix.md
@@ -14,17 +14,13 @@ cargo-fix - Automatically fix lint warnings reported by rustc
 This Cargo subcommand will automatically take rustc's suggestions from
 diagnostics like warnings and apply them to your source code. This is intended
 to help automate tasks that rustc itself already knows how to tell you to fix!
-The `cargo fix` subcommand is also being developed for the Rust 2018 edition
-to provide code the ability to easily opt-in to the new edition without having
-to worry about any breakage.
 
 Executing `cargo fix` will under the hood execute [cargo-check(1)](cargo-check.html). Any warnings
 applicable to your crate will be automatically fixed (if possible) and all
 remaining warnings will be displayed when the check process is finished. For
-example if you'd like to prepare for the 2018 edition, you can do so by
-executing:
+example if you'd like to apply all fixes to the current package, you can run:
 
-    cargo fix --edition
+    cargo fix
 
 which behaves the same as `cargo check --all-targets`.
 
@@ -32,16 +28,34 @@ which behaves the same as `cargo check --all-targets`.
 `cargo check`. If code is conditionally enabled with optional features, you
 will need to enable those features for that code to be analyzed:
 
-    cargo fix --edition --features foo
+    cargo fix --features foo
 
 Similarly, other `cfg` expressions like platform-specific code will need to
 pass `--target` to fix code for the given target.
 
-    cargo fix --edition --target x86_64-pc-windows-gnu
+    cargo fix --target x86_64-pc-windows-gnu
 
 If you encounter any problems with `cargo fix` or otherwise have any questions
 or feature requests please don't hesitate to file an issue at
-<https://github.com/rust-lang/cargo>
+<https://github.com/rust-lang/cargo>.
+
+### Edition migration
+
+The `cargo fix` subcommand can also be used to migrate a package from one
+[edition] to the next. The general procedure is:
+
+1. Run `cargo fix --edition`
+2. Modify `Cargo.toml` to set the [edition field] to the new edition.
+3. Run your project tests to verify that everything still works.
+
+And hopefully that's it! Just keep in mind of the caveats mentioned above that
+`cargo fix` cannot update code for inactive features or `cfg` expressions.
+Also, in some rare cases the compiler is unable to automatically migrate all
+code to the new edition, and this may require manual changes after building
+with the new edition.
+
+[edition]: https://doc.rust-lang.org/edition-guide/editions/transitioning-an-existing-project-to-a-new-edition.html
+[edition field]: ../reference/manifest.html#the-edition-field
 
 ## OPTIONS
 
@@ -56,9 +70,9 @@ code in the working directory for you to inspect and manually fix.</dd>
 
 
 <dt class="option-term" id="option-cargo-fix---edition"><a class="option-anchor" href="#option-cargo-fix---edition"></a><code>--edition</code></dt>
-<dd class="option-desc">Apply changes that will update the code to the latest edition. This will not
+<dd class="option-desc">Apply changes that will update the code to the next edition. This will not
 update the edition in the <code>Cargo.toml</code> manifest, which must be updated
-manually.</dd>
+manually after <code>cargo fix --edition</code> has finished.</dd>
 
 
 <dt class="option-term" id="option-cargo-fix---edition-idioms"><a class="option-anchor" href="#option-cargo-fix---edition-idioms"></a><code>--edition-idioms</code></dt>
@@ -437,7 +451,7 @@ details on environment variables that Cargo reads.
 
        cargo fix
 
-2. Convert a 2015 edition to 2018:
+2. Update a package to prepare it for the next edition:
 
        cargo fix --edition
 
diff --git a/src/etc/man/cargo-fix.1 b/src/etc/man/cargo-fix.1
index 97983d882d7..de59b82640c 100644
--- a/src/etc/man/cargo-fix.1
+++ b/src/etc/man/cargo-fix.1
@@ -11,19 +11,15 @@ cargo\-fix \- Automatically fix lint warnings reported by rustc
 This Cargo subcommand will automatically take rustc's suggestions from
 diagnostics like warnings and apply them to your source code. This is intended
 to help automate tasks that rustc itself already knows how to tell you to fix!
-The \fBcargo fix\fR subcommand is also being developed for the Rust 2018 edition
-to provide code the ability to easily opt\-in to the new edition without having
-to worry about any breakage.
 .sp
 Executing \fBcargo fix\fR will under the hood execute \fBcargo\-check\fR(1). Any warnings
 applicable to your crate will be automatically fixed (if possible) and all
 remaining warnings will be displayed when the check process is finished. For
-example if you'd like to prepare for the 2018 edition, you can do so by
-executing:
+example if you'd like to apply all fixes to the current package, you can run:
 .sp
 .RS 4
 .nf
-cargo fix \-\-edition
+cargo fix
 .fi
 .RE
 .sp
@@ -35,7 +31,7 @@ will need to enable those features for that code to be analyzed:
 .sp
 .RS 4
 .nf
-cargo fix \-\-edition \-\-features foo
+cargo fix \-\-features foo
 .fi
 .RE
 .sp
@@ -44,13 +40,34 @@ pass \fB\-\-target\fR to fix code for the given target.
 .sp
 .RS 4
 .nf
-cargo fix \-\-edition \-\-target x86_64\-pc\-windows\-gnu
+cargo fix \-\-target x86_64\-pc\-windows\-gnu
 .fi
 .RE
 .sp
 If you encounter any problems with \fBcargo fix\fR or otherwise have any questions
 or feature requests please don't hesitate to file an issue at
-<https://github.com/rust\-lang/cargo>
+<https://github.com/rust\-lang/cargo>\&.
+.SS "Edition migration"
+The \fBcargo fix\fR subcommand can also be used to migrate a package from one
+\fIedition\fR <https://doc.rust\-lang.org/edition\-guide/editions/transitioning\-an\-existing\-project\-to\-a\-new\-edition.html> to the next. The general procedure is:
+.sp
+.RS 4
+\h'-04' 1.\h'+01'Run \fBcargo fix \-\-edition\fR
+.RE
+.sp
+.RS 4
+\h'-04' 2.\h'+01'Modify \fBCargo.toml\fR to set the \fIedition field\fR <https://doc.rust\-lang.org/cargo/reference/manifest.html#the\-edition\-field> to the new edition.
+.RE
+.sp
+.RS 4
+\h'-04' 3.\h'+01'Run your project tests to verify that everything still works.
+.RE
+.sp
+And hopefully that's it! Just keep in mind of the caveats mentioned above that
+\fBcargo fix\fR cannot update code for inactive features or \fBcfg\fR expressions.
+Also, in some rare cases the compiler is unable to automatically migrate all
+code to the new edition, and this may require manual changes after building
+with the new edition.
 .SH "OPTIONS"
 .SS "Fix options"
 .sp
@@ -63,9 +80,9 @@ code in the working directory for you to inspect and manually fix.
 .sp
 \fB\-\-edition\fR
 .RS 4
-Apply changes that will update the code to the latest edition. This will not
+Apply changes that will update the code to the next edition. This will not
 update the edition in the \fBCargo.toml\fR manifest, which must be updated
-manually.
+manually after \fBcargo fix \-\-edition\fR has finished.
 .RE
 .sp
 \fB\-\-edition\-idioms\fR
@@ -476,7 +493,7 @@ cargo fix
 .RE
 .sp
 .RS 4
-\h'-04' 2.\h'+01'Convert a 2015 edition to 2018:
+\h'-04' 2.\h'+01'Update a package to prepare it for the next edition:
 .sp
 .RS 4
 .nf

From aa61976c5f853c1cac07d03115a492fde0ab386e Mon Sep 17 00:00:00 2001
From: Eric Huss <eric@huss.org>
Date: Fri, 19 Feb 2021 12:57:36 -0800
Subject: [PATCH 08/11] Make edition transitions easier.

This attempts to centralize all the edition stuff in one place (the
`Edition` enum) so that adding a new edition or stabilizing one should
be relatively little work (and more importantly, we don't miss things).

Importantly, this changes `cargo new` to default to the latest stable.
It also changes the `cargo fix --edition-idiom` behavior to only apply
idioms for the *current* edition.
---
 src/cargo/core/features.rs        | 42 +++++++++++++++++++++++++++++--
 src/cargo/ops/cargo_new.rs        |  4 +--
 src/cargo/ops/fix.rs              |  4 +--
 src/cargo/util/command_prelude.rs |  4 +--
 tests/testsuite/edition.rs        | 24 ++++++++++--------
 tests/testsuite/fix.rs            | 37 +++++++++++++--------------
 6 files changed, 78 insertions(+), 37 deletions(-)

diff --git a/src/cargo/core/features.rs b/src/cargo/core/features.rs
index 4419ff4ff7e..ad1a42e59ed 100644
--- a/src/cargo/core/features.rs
+++ b/src/cargo/core/features.rs
@@ -118,9 +118,35 @@ pub enum Edition {
     Edition2021,
 }
 
+// Adding a new edition:
+// - Add the next edition to the enum.
+// - Update every match expression that now fails to compile.
+// - Update the `FromStr` impl.
+// - Update CLI_VALUES to include the new edition.
+// - Set LATEST_UNSTABLE to Some with the new edition.
+// - Add an unstable feature to the features! macro below for the new edition.
+// - Gate on that new feature in TomlManifest::to_real_manifest.
+// - Update the shell completion files.
+// - Update any failing tests (hopefully there are very few).
+//
+// Stabilization instructions:
+// - Set LATEST_UNSTABLE to None.
+// - Set LATEST_STABLE to the new version.
+// - Update `is_stable` to `true`.
+// - Set the editionNNNN feature to stable in the features macro below.
+// - Update the man page for the --edition flag.
 impl Edition {
-    /// The latest edition (may or may not be stable).
-    pub const LATEST: Edition = Edition::Edition2021;
+    /// The latest edition that is unstable.
+    ///
+    /// This is `None` if there is no next unstable edition.
+    pub const LATEST_UNSTABLE: Option<Edition> = Some(Edition::Edition2021);
+    /// The latest stable edition.
+    pub const LATEST_STABLE: Edition = Edition::Edition2018;
+    /// Possible values allowed for the `--edition` CLI flag.
+    ///
+    /// This requires a static value due to the way clap works, otherwise I
+    /// would have built this dynamically.
+    pub const CLI_VALUES: &'static [&'static str] = &["2015", "2018", "2021"];
 
     /// Returns the first version that a particular edition was released on
     /// stable.
@@ -180,6 +206,18 @@ impl Edition {
             Edition2021 => false,
         }
     }
+
+    /// Whether or not this edition supports the `rust_*_idioms` lint.
+    ///
+    /// Ideally this would not be necessary...
+    pub(crate) fn supports_idiom_lint(&self) -> bool {
+        use Edition::*;
+        match self {
+            Edition2015 => false,
+            Edition2018 => true,
+            Edition2021 => false,
+        }
+    }
 }
 
 impl fmt::Display for Edition {
diff --git a/src/cargo/ops/cargo_new.rs b/src/cargo/ops/cargo_new.rs
index 4ade5d3dd90..06b88084c5e 100644
--- a/src/cargo/ops/cargo_new.rs
+++ b/src/cargo/ops/cargo_new.rs
@@ -1,4 +1,4 @@
-use crate::core::{Shell, Workspace};
+use crate::core::{Edition, Shell, Workspace};
 use crate::util::errors::{CargoResult, CargoResultExt};
 use crate::util::{existing_vcs_repo, FossilRepo, GitRepo, HgRepo, PijulRepo};
 use crate::util::{paths, restricted_names, Config};
@@ -743,7 +743,7 @@ edition = {}
             },
             match opts.edition {
                 Some(edition) => toml::Value::String(edition.to_string()),
-                None => toml::Value::String("2018".to_string()),
+                None => toml::Value::String(Edition::LATEST_STABLE.to_string()),
             },
             match opts.registry {
                 Some(registry) => format!(
diff --git a/src/cargo/ops/fix.rs b/src/cargo/ops/fix.rs
index 4e6d611da06..6e53964c674 100644
--- a/src/cargo/ops/fix.rs
+++ b/src/cargo/ops/fix.rs
@@ -675,8 +675,8 @@ impl FixArgs {
         cmd.args(&self.other).arg("--cap-lints=warn");
         if let Some(edition) = self.enabled_edition {
             cmd.arg("--edition").arg(edition.to_string());
-            if self.idioms && edition >= Edition::Edition2018 {
-                cmd.arg("-Wrust-2018-idioms");
+            if self.idioms && edition.supports_idiom_lint() {
+                cmd.arg(format!("-Wrust-{}-idioms", edition));
             }
         }
 
diff --git a/src/cargo/util/command_prelude.rs b/src/cargo/util/command_prelude.rs
index 4f56ab242f4..06b3fcaddf5 100644
--- a/src/cargo/util/command_prelude.rs
+++ b/src/cargo/util/command_prelude.rs
@@ -1,5 +1,5 @@
 use crate::core::compiler::{BuildConfig, MessageFormat};
-use crate::core::Workspace;
+use crate::core::{Edition, Workspace};
 use crate::ops::{CompileFilter, CompileOptions, NewOptions, Packages, VersionControl};
 use crate::sources::CRATES_IO_REGISTRY;
 use crate::util::important_paths::find_root_manifest_for_wd;
@@ -188,7 +188,7 @@ pub trait AppExt: Sized {
         ._arg(opt("lib", "Use a library template"))
         ._arg(
             opt("edition", "Edition to set for the crate generated")
-                .possible_values(&["2015", "2018", "2021"])
+                .possible_values(Edition::CLI_VALUES)
                 .value_name("YEAR"),
         )
         ._arg(
diff --git a/tests/testsuite/edition.rs b/tests/testsuite/edition.rs
index c675fdbb98b..e7510dc358e 100644
--- a/tests/testsuite/edition.rs
+++ b/tests/testsuite/edition.rs
@@ -39,11 +39,13 @@ fn edition_unstable_gated() {
     // During the period where a new edition is coming up, but not yet stable,
     // this test will verify that it cannot be used on stable. If there is no
     // next edition, it does nothing.
-    let next = Edition::LATEST;
-    if next.is_stable() {
-        eprintln!("Next edition is currently not available, skipping test.");
-        return;
-    }
+    let next = match Edition::LATEST_UNSTABLE {
+        Some(next) => next,
+        None => {
+            eprintln!("Next edition is currently not available, skipping test.");
+            return;
+        }
+    };
     let p = project()
         .file(
             "Cargo.toml",
@@ -87,11 +89,13 @@ fn edition_unstable() {
         // This test is fundamentally always nightly.
         return;
     }
-    let next = Edition::LATEST;
-    if next.is_stable() {
-        eprintln!("Next edition is currently not available, skipping test.");
-        return;
-    }
+    let next = match Edition::LATEST_UNSTABLE {
+        Some(next) => next,
+        None => {
+            eprintln!("Next edition is currently not available, skipping test.");
+            return;
+        }
+    };
     let p = project()
         .file(
             "Cargo.toml",
diff --git a/tests/testsuite/fix.rs b/tests/testsuite/fix.rs
index b76fda4b141..3e5c922955b 100644
--- a/tests/testsuite/fix.rs
+++ b/tests/testsuite/fix.rs
@@ -795,12 +795,14 @@ fn prepare_for_unstable() {
     // During the period where a new edition is coming up, but not yet stable,
     // this test will verify that it cannot be migrated to on stable. If there
     // is no next edition, it does nothing.
-    let next = Edition::LATEST;
-    if next.is_stable() {
-        eprintln!("Next edition is currently not available, skipping test.");
-        return;
-    }
-    let latest_stable = next.previous().unwrap();
+    let next = match Edition::LATEST_UNSTABLE {
+        Some(next) => next,
+        None => {
+            eprintln!("Next edition is currently not available, skipping test.");
+            return;
+        }
+    };
+    let latest_stable = Edition::LATEST_STABLE;
     let p = project()
         .file(
             "Cargo.toml",
@@ -853,12 +855,7 @@ To learn more, run the command again with --verbose.
 #[cargo_test]
 fn prepare_for_latest_stable() {
     // This is the stable counterpart of prepare_for_unstable.
-    let latest = Edition::LATEST;
-    let latest_stable = if latest.is_stable() {
-        latest
-    } else {
-        latest.previous().unwrap()
-    };
+    let latest_stable = Edition::LATEST_STABLE;
     let previous = latest_stable.previous().unwrap();
     let p = project()
         .file(
@@ -897,11 +894,13 @@ fn prepare_for_already_on_latest_unstable() {
         // This test is fundamentally always nightly.
         return;
     }
-    let next_edition = Edition::LATEST;
-    if next_edition.is_stable() {
-        eprintln!("Next edition is currently not available, skipping test.");
-        return;
-    }
+    let next_edition = match Edition::LATEST_UNSTABLE {
+        Some(next) => next,
+        None => {
+            eprintln!("Next edition is currently not available, skipping test.");
+            return;
+        }
+    };
     let p = project()
         .file(
             "Cargo.toml",
@@ -936,11 +935,11 @@ fn prepare_for_already_on_latest_unstable() {
 #[cargo_test]
 fn prepare_for_already_on_latest_stable() {
     // Stable counterpart of prepare_for_already_on_latest_unstable.
-    if !Edition::LATEST.is_stable() {
+    if Edition::LATEST_UNSTABLE.is_some() {
         eprintln!("This test cannot run while the latest edition is unstable, skipping.");
         return;
     }
-    let latest_stable = Edition::LATEST;
+    let latest_stable = Edition::LATEST_STABLE;
     let p = project()
         .file(
             "Cargo.toml",

From 15513ce7416d9782e727634ef0c809bc28b60950 Mon Sep 17 00:00:00 2001
From: Eric Huss <eric@huss.org>
Date: Fri, 19 Feb 2021 12:58:30 -0800
Subject: [PATCH 09/11] Add some more details to the `cargo fix --edition`
 procedure.

---
 src/doc/man/cargo-fix.md                | 10 ++++++++--
 src/doc/man/generated_txt/cargo-fix.txt | 10 ++++++++--
 src/doc/src/commands/cargo-fix.md       | 10 ++++++++--
 src/etc/man/cargo-fix.1                 |  9 +++++++--
 4 files changed, 31 insertions(+), 8 deletions(-)

diff --git a/src/doc/man/cargo-fix.md b/src/doc/man/cargo-fix.md
index 7e95a0eafc8..ab1e24e4759 100644
--- a/src/doc/man/cargo-fix.md
+++ b/src/doc/man/cargo-fix.md
@@ -44,9 +44,15 @@ or feature requests please don't hesitate to file an issue at
 The `cargo fix` subcommand can also be used to migrate a package from one
 [edition] to the next. The general procedure is:
 
-1. Run `cargo fix --edition`
+1. Run `cargo fix --edition`. Consider also using the `--all-features` flag if
+   your project has multiple features. You may also want to run `cargo fix
+   --edition` multiple times with different `--target` flags if your project
+   has platform-specific code gated by `cfg` attributes.
 2. Modify `Cargo.toml` to set the [edition field] to the new edition.
-3. Run your project tests to verify that everything still works.
+3. Run your project tests to verify that everything still works. If new
+   warnings are issued, you may want to consider running `cargo fix` again
+   (without the `--edition` flag) to apply any suggestions given by the
+   compiler.
 
 And hopefully that's it! Just keep in mind of the caveats mentioned above that
 `cargo fix` cannot update code for inactive features or `cfg` expressions.
diff --git a/src/doc/man/generated_txt/cargo-fix.txt b/src/doc/man/generated_txt/cargo-fix.txt
index d74d796ac42..c2b3aa5300d 100644
--- a/src/doc/man/generated_txt/cargo-fix.txt
+++ b/src/doc/man/generated_txt/cargo-fix.txt
@@ -43,13 +43,19 @@ DESCRIPTION
        <https://doc.rust-lang.org/edition-guide/editions/transitioning-an-existing-project-to-a-new-edition.html>
        to the next. The general procedure is:
 
-       1. Run cargo fix --edition
+       1. Run cargo fix --edition. Consider also using the --all-features flag
+          if your project has multiple features. You may also want to run cargo
+          fix --edition multiple times with different --target flags if your
+          project has platform-specific code gated by cfg attributes.
 
        2. Modify Cargo.toml to set the edition field
           <https://doc.rust-lang.org/cargo/reference/manifest.html#the-edition-field>
           to the new edition.
 
-       3. Run your project tests to verify that everything still works.
+       3. Run your project tests to verify that everything still works. If new
+          warnings are issued, you may want to consider running cargo fix again
+          (without the --edition flag) to apply any suggestions given by the
+          compiler.
 
        And hopefully that's it! Just keep in mind of the caveats mentioned
        above that cargo fix cannot update code for inactive features or cfg
diff --git a/src/doc/src/commands/cargo-fix.md b/src/doc/src/commands/cargo-fix.md
index 4e9430e924d..2f558b12549 100644
--- a/src/doc/src/commands/cargo-fix.md
+++ b/src/doc/src/commands/cargo-fix.md
@@ -44,9 +44,15 @@ or feature requests please don't hesitate to file an issue at
 The `cargo fix` subcommand can also be used to migrate a package from one
 [edition] to the next. The general procedure is:
 
-1. Run `cargo fix --edition`
+1. Run `cargo fix --edition`. Consider also using the `--all-features` flag if
+   your project has multiple features. You may also want to run `cargo fix
+   --edition` multiple times with different `--target` flags if your project
+   has platform-specific code gated by `cfg` attributes.
 2. Modify `Cargo.toml` to set the [edition field] to the new edition.
-3. Run your project tests to verify that everything still works.
+3. Run your project tests to verify that everything still works. If new
+   warnings are issued, you may want to consider running `cargo fix` again
+   (without the `--edition` flag) to apply any suggestions given by the
+   compiler.
 
 And hopefully that's it! Just keep in mind of the caveats mentioned above that
 `cargo fix` cannot update code for inactive features or `cfg` expressions.
diff --git a/src/etc/man/cargo-fix.1 b/src/etc/man/cargo-fix.1
index de59b82640c..829caca798c 100644
--- a/src/etc/man/cargo-fix.1
+++ b/src/etc/man/cargo-fix.1
@@ -52,7 +52,9 @@ The \fBcargo fix\fR subcommand can also be used to migrate a package from one
 \fIedition\fR <https://doc.rust\-lang.org/edition\-guide/editions/transitioning\-an\-existing\-project\-to\-a\-new\-edition.html> to the next. The general procedure is:
 .sp
 .RS 4
-\h'-04' 1.\h'+01'Run \fBcargo fix \-\-edition\fR
+\h'-04' 1.\h'+01'Run \fBcargo fix \-\-edition\fR\&. Consider also using the \fB\-\-all\-features\fR flag if
+your project has multiple features. You may also want to run \fBcargo fix \-\-edition\fR multiple times with different \fB\-\-target\fR flags if your project
+has platform\-specific code gated by \fBcfg\fR attributes.
 .RE
 .sp
 .RS 4
@@ -60,7 +62,10 @@ The \fBcargo fix\fR subcommand can also be used to migrate a package from one
 .RE
 .sp
 .RS 4
-\h'-04' 3.\h'+01'Run your project tests to verify that everything still works.
+\h'-04' 3.\h'+01'Run your project tests to verify that everything still works. If new
+warnings are issued, you may want to consider running \fBcargo fix\fR again
+(without the \fB\-\-edition\fR flag) to apply any suggestions given by the
+compiler.
 .RE
 .sp
 And hopefully that's it! Just keep in mind of the caveats mentioned above that

From c303213748374c412a50dfca2bb8d4d1e7010d48 Mon Sep 17 00:00:00 2001
From: Eric Huss <eric@huss.org>
Date: Fri, 19 Feb 2021 13:08:59 -0800
Subject: [PATCH 10/11] `cargo fix`: Remove --prepare-for option.

This was deprecated, never officially part of the stable release.
---
 src/bin/cargo/commands/fix.rs | 12 ------------
 src/cargo/core/features.rs    | 11 +++++++++++
 src/cargo/ops/fix.rs          | 26 ++++++++------------------
 tests/testsuite/fix.rs        | 21 +--------------------
 4 files changed, 20 insertions(+), 50 deletions(-)

diff --git a/src/bin/cargo/commands/fix.rs b/src/bin/cargo/commands/fix.rs
index bbcf6f7d4e5..49fe40cd8ea 100644
--- a/src/bin/cargo/commands/fix.rs
+++ b/src/bin/cargo/commands/fix.rs
@@ -41,17 +41,6 @@ pub fn cli() -> App {
                 .long("edition")
                 .help("Fix in preparation for the next edition"),
         )
-        .arg(
-            // This is a deprecated argument, we'll want to phase it out
-            // eventually.
-            Arg::with_name("prepare-for")
-                .long("prepare-for")
-                .help("Fix warnings in preparation of an edition upgrade")
-                .takes_value(true)
-                .possible_values(&["2018"])
-                .conflicts_with("edition")
-                .hidden(true),
-        )
         .arg(
             Arg::with_name("idioms")
                 .long("edition-idioms")
@@ -111,7 +100,6 @@ pub fn exec(config: &mut Config, args: &ArgMatches<'_>) -> CliResult {
         &ws,
         &mut ops::FixOptions {
             edition: args.is_present("edition"),
-            prepare_for: args.value_of("prepare-for"),
             idioms: args.is_present("idioms"),
             compile_opts: opts,
             allow_dirty: args.is_present("allow-dirty"),
diff --git a/src/cargo/core/features.rs b/src/cargo/core/features.rs
index ad1a42e59ed..1162a678e1f 100644
--- a/src/cargo/core/features.rs
+++ b/src/cargo/core/features.rs
@@ -182,6 +182,17 @@ impl Edition {
         }
     }
 
+    /// Returns the next edition from this edition, returning the last edition
+    /// if this is already the last one.
+    pub fn saturating_next(&self) -> Edition {
+        use Edition::*;
+        match self {
+            Edition2015 => Edition2018,
+            Edition2018 => Edition2021,
+            Edition2021 => Edition2021,
+        }
+    }
+
     /// Updates the given [`ProcessBuilder`] to include the appropriate flags
     /// for setting the edition.
     pub(crate) fn cmd_edition_arg(&self, cmd: &mut ProcessBuilder) {
diff --git a/src/cargo/ops/fix.rs b/src/cargo/ops/fix.rs
index 6e53964c674..c1d1f20d2ad 100644
--- a/src/cargo/ops/fix.rs
+++ b/src/cargo/ops/fix.rs
@@ -59,13 +59,11 @@ use crate::util::{existing_vcs_repo, LockServer, LockServerClient};
 
 const FIX_ENV: &str = "__CARGO_FIX_PLZ";
 const BROKEN_CODE_ENV: &str = "__CARGO_FIX_BROKEN_CODE";
-const PREPARE_FOR_ENV: &str = "__CARGO_FIX_PREPARE_FOR";
 const EDITION_ENV: &str = "__CARGO_FIX_EDITION";
 const IDIOMS_ENV: &str = "__CARGO_FIX_IDIOMS";
 
-pub struct FixOptions<'a> {
+pub struct FixOptions {
     pub edition: bool,
-    pub prepare_for: Option<&'a str>,
     pub idioms: bool,
     pub compile_opts: CompileOptions,
     pub allow_dirty: bool,
@@ -74,7 +72,7 @@ pub struct FixOptions<'a> {
     pub broken_code: bool,
 }
 
-pub fn fix(ws: &Workspace<'_>, opts: &mut FixOptions<'_>) -> CargoResult<()> {
+pub fn fix(ws: &Workspace<'_>, opts: &mut FixOptions) -> CargoResult<()> {
     check_version_control(ws.config(), opts)?;
 
     // Spin up our lock server, which our subprocesses will use to synchronize fixes.
@@ -91,8 +89,6 @@ pub fn fix(ws: &Workspace<'_>, opts: &mut FixOptions<'_>) -> CargoResult<()> {
 
     if opts.edition {
         wrapper.env(EDITION_ENV, "1");
-    } else if let Some(edition) = opts.prepare_for {
-        wrapper.env(PREPARE_FOR_ENV, edition);
     }
     if opts.idioms {
         wrapper.env(IDIOMS_ENV, "1");
@@ -125,7 +121,7 @@ pub fn fix(ws: &Workspace<'_>, opts: &mut FixOptions<'_>) -> CargoResult<()> {
     Ok(())
 }
 
-fn check_version_control(config: &Config, opts: &FixOptions<'_>) -> CargoResult<()> {
+fn check_version_control(config: &Config, opts: &FixOptions) -> CargoResult<()> {
     if opts.allow_no_vcs {
         return Ok(());
     }
@@ -647,17 +643,11 @@ impl FixArgs {
         let file = file.ok_or_else(|| anyhow::anyhow!("could not find .rs file in rustc args"))?;
         let idioms = env::var(IDIOMS_ENV).is_ok();
 
-        let prepare_for_edition = if let Ok(s) = env::var(PREPARE_FOR_ENV) {
-            Some(s.parse()?)
-        } else if env::var(EDITION_ENV).is_ok() {
-            match enabled_edition {
-                None | Some(Edition::Edition2015) => Some(Edition::Edition2018),
-                Some(Edition::Edition2018) => Some(Edition::Edition2021),
-                Some(Edition::Edition2021) => Some(Edition::Edition2021),
-            }
-        } else {
-            None
-        };
+        let prepare_for_edition = env::var(EDITION_ENV).ok().map(|_| {
+            enabled_edition
+                .unwrap_or(Edition::Edition2015)
+                .saturating_next()
+        });
 
         Ok(FixArgs {
             file,
diff --git a/tests/testsuite/fix.rs b/tests/testsuite/fix.rs
index 3e5c922955b..7aa23bd34bf 100644
--- a/tests/testsuite/fix.rs
+++ b/tests/testsuite/fix.rs
@@ -986,7 +986,7 @@ fn fix_overlapping() {
         )
         .build();
 
-    p.cargo("fix --allow-no-vcs --prepare-for 2018 --lib")
+    p.cargo("fix --allow-no-vcs --edition --lib")
         .with_stderr(
             "\
 [CHECKING] foo [..]
@@ -1044,25 +1044,6 @@ fn idioms_2015_ok() {
     p.cargo("fix --edition-idioms --allow-no-vcs").run();
 }
 
-#[cargo_test]
-fn both_edition_migrate_flags() {
-    let p = project().file("src/lib.rs", "").build();
-
-    let stderr = "\
-error: The argument '--edition' cannot be used with '--prepare-for <prepare-for>'
-
-USAGE:
-    cargo[..] fix --edition
-
-For more information try --help
-";
-
-    p.cargo("fix --prepare-for 2018 --edition")
-        .with_status(1)
-        .with_stderr(stderr)
-        .run();
-}
-
 #[cargo_test]
 fn shows_warnings_on_second_run_without_changes() {
     let p = project()

From a82a23c164c0024f53c1042931bf0a67c45cba78 Mon Sep 17 00:00:00 2001
From: Eric Huss <eric@huss.org>
Date: Fri, 19 Feb 2021 14:23:39 -0800
Subject: [PATCH 11/11] Change how workspace resolve behavior is calculated.

This fixes an issue where warnings would be printed for packages
migrating to 2021 in a workspace (that the "resolver" field is ignored,
which is wrong).

This also places the default resolver logic in one place, and should
make it easier to update later.
---
 src/cargo/core/workspace.rs | 45 ++++++++++++++++++++++++-------------
 src/cargo/util/toml/mod.rs  |  8 +------
 2 files changed, 31 insertions(+), 22 deletions(-)

diff --git a/src/cargo/core/workspace.rs b/src/cargo/core/workspace.rs
index 864cef730ed..f72f0915c9f 100644
--- a/src/cargo/core/workspace.rs
+++ b/src/cargo/core/workspace.rs
@@ -13,7 +13,7 @@ use crate::core::features::Features;
 use crate::core::registry::PackageRegistry;
 use crate::core::resolver::features::RequestedFeatures;
 use crate::core::resolver::ResolveBehavior;
-use crate::core::{Dependency, PackageId, PackageIdSpec};
+use crate::core::{Dependency, Edition, PackageId, PackageIdSpec};
 use crate::core::{EitherManifest, Package, SourceId, VirtualManifest};
 use crate::ops;
 use crate::sources::PathSource;
@@ -88,7 +88,7 @@ pub struct Workspace<'cfg> {
     ignore_lock: bool,
 
     /// The resolver behavior specified with the `resolver` field.
-    resolve_behavior: Option<ResolveBehavior>,
+    resolve_behavior: ResolveBehavior,
 
     /// Workspace-level custom metadata
     custom_metadata: Option<toml::Value>,
@@ -164,10 +164,7 @@ impl<'cfg> Workspace<'cfg> {
             .load_workspace_config()?
             .and_then(|cfg| cfg.custom_metadata);
         ws.find_members()?;
-        ws.resolve_behavior = match ws.root_maybe() {
-            MaybePackage::Package(p) => p.manifest().resolve_behavior(),
-            MaybePackage::Virtual(vm) => vm.resolve_behavior(),
-        };
+        ws.set_resolve_behavior();
         ws.validate()?;
         Ok(ws)
     }
@@ -189,7 +186,7 @@ impl<'cfg> Workspace<'cfg> {
             require_optional_deps: true,
             loaded_packages: RefCell::new(HashMap::new()),
             ignore_lock: false,
-            resolve_behavior: None,
+            resolve_behavior: ResolveBehavior::V1,
             custom_metadata: None,
         }
     }
@@ -203,11 +200,11 @@ impl<'cfg> Workspace<'cfg> {
         let mut ws = Workspace::new_default(current_manifest, config);
         ws.root_manifest = Some(root_path.join("Cargo.toml"));
         ws.target_dir = config.target_dir()?;
-        ws.resolve_behavior = manifest.resolve_behavior();
         ws.packages
             .packages
             .insert(root_path, MaybePackage::Virtual(manifest));
         ws.find_members()?;
+        ws.set_resolve_behavior();
         // TODO: validation does not work because it walks up the directory
         // tree looking for the root which is a fake file that doesn't exist.
         Ok(ws)
@@ -231,7 +228,6 @@ impl<'cfg> Workspace<'cfg> {
         let mut ws = Workspace::new_default(package.manifest_path().to_path_buf(), config);
         ws.is_ephemeral = true;
         ws.require_optional_deps = require_optional_deps;
-        ws.resolve_behavior = package.manifest().resolve_behavior();
         let key = ws.current_manifest.parent().unwrap();
         let id = package.package_id();
         let package = MaybePackage::Package(package);
@@ -244,9 +240,28 @@ impl<'cfg> Workspace<'cfg> {
         ws.members.push(ws.current_manifest.clone());
         ws.member_ids.insert(id);
         ws.default_members.push(ws.current_manifest.clone());
+        ws.set_resolve_behavior();
         Ok(ws)
     }
 
+    fn set_resolve_behavior(&mut self) {
+        // - If resolver is specified in the workspace definition, use that.
+        // - If the root package specifies the resolver, use that.
+        // - If the root package specifies edition 2021, use v2.
+        // - Otherwise, use the default v1.
+        self.resolve_behavior = match self.root_maybe() {
+            MaybePackage::Package(p) => p.manifest().resolve_behavior().or_else(|| {
+                if p.manifest().edition() >= Edition::Edition2021 {
+                    Some(ResolveBehavior::V2)
+                } else {
+                    None
+                }
+            }),
+            MaybePackage::Virtual(vm) => vm.resolve_behavior(),
+        }
+        .unwrap_or(ResolveBehavior::V1);
+    }
+
     /// Returns the current package of this workspace.
     ///
     /// Note that this can return an error if it the current manifest is
@@ -634,7 +649,7 @@ impl<'cfg> Workspace<'cfg> {
     }
 
     pub fn resolve_behavior(&self) -> ResolveBehavior {
-        self.resolve_behavior.unwrap_or(ResolveBehavior::V1)
+        self.resolve_behavior
     }
 
     /// Returns `true` if this workspace uses the new CLI features behavior.
@@ -843,11 +858,11 @@ impl<'cfg> Workspace<'cfg> {
                 if !manifest.patch().is_empty() {
                     emit_warning("patch")?;
                 }
-                if manifest.resolve_behavior().is_some()
-                    && manifest.resolve_behavior() != self.resolve_behavior
-                {
-                    // Only warn if they don't match.
-                    emit_warning("resolver")?;
+                if let Some(behavior) = manifest.resolve_behavior() {
+                    if behavior != self.resolve_behavior {
+                        // Only warn if they don't match.
+                        emit_warning("resolver")?;
+                    }
                 }
             }
         }
diff --git a/src/cargo/util/toml/mod.rs b/src/cargo/util/toml/mod.rs
index fe7fcdb08ad..683f5e7c825 100644
--- a/src/cargo/util/toml/mod.rs
+++ b/src/cargo/util/toml/mod.rs
@@ -1132,13 +1132,7 @@ impl TomlManifest {
             project.resolver.as_ref(),
             me.workspace.as_ref().and_then(|ws| ws.resolver.as_ref()),
         ) {
-            (None, None) => {
-                if edition == Edition::Edition2021 {
-                    Some(ResolveBehavior::V2)
-                } else {
-                    None
-                }
-            }
+            (None, None) => None,
             (Some(s), None) | (None, Some(s)) => Some(ResolveBehavior::from_manifest(s)?),
             (Some(_), Some(_)) => {
                 bail!("cannot specify `resolver` field in both `[workspace]` and `[package]`")