When compiling without a specified --edition, emit a note

compiler/rustc_driver_impl/src/lib.rs

@@ -191,7 +191,9 @@ pub fn run_compiler(at_args: &[String], callbacks: &mut (dyn Callbacks + Send))
         HandledOptions::HelpOnly(matches) => (matches, true),
     };
 
-    let sopts = config::build_session_options(&mut default_early_dcx, &matches);
+    let input = make_input(&default_early_dcx, &matches.free);
+    let has_input = input.is_some();
+    let sopts = config::build_session_options(&mut default_early_dcx, &matches, has_input);
     // fully initialize ice path static once unstable options are available as context
     let ice_file = ice_path_with_config(Some(&sopts.unstable_opts)).clone();
 
@@ -200,8 +202,6 @@ pub fn run_compiler(at_args: &[String], callbacks: &mut (dyn Callbacks + Send))
         return;
     }
 
-    let input = make_input(&default_early_dcx, &matches.free);
-    let has_input = input.is_some();
     let (odir, ofile) = make_output(&matches);
 
     drop(default_early_dcx);

compiler/rustc_interface/src/tests.rs

@@ -42,7 +42,7 @@ where
 {
     let mut early_dcx = EarlyDiagCtxt::new(ErrorOutputType::default());
     let matches = optgroups().parse(args).unwrap();
-    let sessopts = build_session_options(&mut early_dcx, &matches);
+    let sessopts = build_session_options(&mut early_dcx, &matches, true);
     let target = rustc_session::config::build_target_config(
         &early_dcx,
         &sessopts.target_triple,
@@ -941,7 +941,7 @@ fn test_edition_parsing() {
     let mut early_dcx = EarlyDiagCtxt::new(ErrorOutputType::default());
 
     let matches = optgroups().parse(&["--edition=2018".to_string()]).unwrap();
-    let sessopts = build_session_options(&mut early_dcx, &matches);
+    let sessopts = build_session_options(&mut early_dcx, &matches, false);
     assert!(sessopts.edition == Edition::Edition2018)
 }
 
@@ -952,7 +952,7 @@ fn test_assumptions_on_binders_enables_next_solver_globally() {
 
     // `-Zassumptions-on-binders` alone enables the next solver globally.
     let matches = optgroups().parse(&["-Zassumptions-on-binders".to_string()]).unwrap();
-    let opts = build_session_options(&mut early_dcx, &matches);
+    let opts = build_session_options(&mut early_dcx, &matches, false);
     assert!(opts.unstable_opts.assumptions_on_binders);
     assert_eq!(opts.unstable_opts.next_solver, globally);
 
@@ -963,7 +963,7 @@ fn test_assumptions_on_binders_enables_next_solver_globally() {
         ["-Znext-solver=coherence".to_string(), "-Zassumptions-on-binders".to_string()],
     ] {
         let matches = optgroups().parse(&args).unwrap();
-        let opts = build_session_options(&mut early_dcx, &matches);
+        let opts = build_session_options(&mut early_dcx, &matches, false);
         assert!(opts.unstable_opts.assumptions_on_binders);
         assert_eq!(opts.unstable_opts.next_solver, globally);
     }
@@ -976,7 +976,7 @@ fn test_assumptions_on_binders_enables_next_solver_globally() {
         ["-Znext-solver=no".to_string(), "-Zassumptions-on-binders".to_string()],
     ] {
         let matches = optgroups().parse(&args).unwrap();
-        let opts = build_session_options(&mut early_dcx, &matches);
+        let opts = build_session_options(&mut early_dcx, &matches, false);
         assert!(opts.unstable_opts.assumptions_on_binders);
         assert_eq!(opts.unstable_opts.next_solver, globally);
     }

compiler/rustc_session/src/config.rs

@@ -21,7 +21,9 @@ use rustc_errors::{ColorConfig, DiagCtxtFlags};
 use rustc_feature::UnstableFeatures;
 use rustc_hashes::Hash64;
 use rustc_macros::{BlobDecodable, Decodable, Encodable, StableHash};
-use rustc_span::edition::{DEFAULT_EDITION, EDITION_NAME_LIST, Edition, LATEST_STABLE_EDITION};
+use rustc_span::edition::{
+    DEFAULT_EDITION, EDITION_NAME_LIST, EDITION_NAME_LIST_STABLE, Edition, LATEST_STABLE_EDITION,
+};
 use rustc_span::source_map::FilePathMapping;
 use rustc_span::{
     FileName, RealFileName, RemapPathScopeComponents, SourceFileHashAlgorithm, Symbol, sym,
@@ -2365,22 +2367,35 @@ pub fn parse_error_format(
     error_format
 }
 
-pub fn parse_crate_edition(early_dcx: &EarlyDiagCtxt, matches: &getopts::Matches) -> Edition {
+pub fn parse_crate_edition(
+    early_dcx: &EarlyDiagCtxt,
+    matches: &getopts::Matches,
+    has_input: bool,
+) -> Edition {
+    let is_nightly = nightly_options::match_is_nightly_build(matches);
+    let edition_list = if is_nightly { EDITION_NAME_LIST } else { EDITION_NAME_LIST_STABLE };
     let edition = match matches.opt_str("edition") {
         Some(arg) => Edition::from_str(&arg).unwrap_or_else(|_| {
             early_dcx.early_fatal(format!(
-                "argument for `--edition` must be one of: \
-                     {EDITION_NAME_LIST}. (instead was `{arg}`)"
+                "argument for `--edition` must be one of: {edition_list} (instead was `{arg}`)",
             ))
         }),
-        None => DEFAULT_EDITION,
+        None => {
+            if has_input {
+                eprintln!(
+                    "`--edition` is unspecified, defaulting to `{DEFAULT_EDITION}` while the \
+                     latest is `{LATEST_STABLE_EDITION}`; it must be one of: {edition_list}\n",
+                );
+            }
+            DEFAULT_EDITION
+        }
     };
 
     if !edition.is_stable() && !nightly_options::is_unstable_enabled(matches) {
-        let is_nightly = nightly_options::match_is_nightly_build(matches);
         let msg = if !is_nightly {
             format!(
-                "the crate requires edition {edition}, but the latest edition supported by this Rust version is {LATEST_STABLE_EDITION}"
+                "the crate requires edition {edition}, but the latest edition supported by this \
+                 Rust version is {LATEST_STABLE_EDITION}"
             )
         } else {
             format!("edition {edition} is unstable and only available with -Z unstable-options")
@@ -2677,10 +2692,14 @@ fn parse_remap_path_prefix(
 
 // JUSTIFICATION: before wrapper fn is available
 #[allow(rustc::bad_opt_access)]
-pub fn build_session_options(early_dcx: &mut EarlyDiagCtxt, matches: &getopts::Matches) -> Options {
+pub fn build_session_options(
+    early_dcx: &mut EarlyDiagCtxt,
+    matches: &getopts::Matches,
+    has_input: bool,
+) -> Options {
     let color = parse_color(early_dcx, matches);
 
-    let edition = parse_crate_edition(early_dcx, matches);
+    let edition = parse_crate_edition(early_dcx, matches, has_input);
 
     let crate_name = matches.opt_str("crate-name");
     let unstable_features = UnstableFeatures::from_environment(crate_name.as_deref());

compiler/rustc_span/src/edition.rs

@@ -45,21 +45,18 @@ pub const ALL_EDITIONS: &[Edition] = &[
     Edition::EditionFuture,
 ];
 
+/// All the valid editions that `--edition` will accept on nightly.
 pub const EDITION_NAME_LIST: &str = "<2015|2018|2021|2024|future>";
+/// All the valid editions on stable, which doesn't include `future`.
+pub const EDITION_NAME_LIST_STABLE: &str = "<2015|2018|2021|2024>";
 
 pub const DEFAULT_EDITION: Edition = Edition::Edition2015;
 
 pub const LATEST_STABLE_EDITION: Edition = Edition::Edition2024;
 
 impl fmt::Display for Edition {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        let s = match *self {
-            Edition::Edition2015 => "2015",
-            Edition::Edition2018 => "2018",
-            Edition::Edition2021 => "2021",
-            Edition::Edition2024 => "2024",
-            Edition::EditionFuture => "future",
-        };
+        let s = self.as_str();
         write!(f, "{s}")
     }
 }
@@ -75,6 +72,16 @@ impl Edition {
         }
     }
 
+    pub fn as_str(&self) -> &'static str {
+        match *self {
+            Edition::Edition2015 => "2015",
+            Edition::Edition2018 => "2018",
+            Edition::Edition2021 => "2021",
+            Edition::Edition2024 => "2024",
+            Edition::EditionFuture => "future",
+        }
+    }
+
     pub fn is_stable(self) -> bool {
         match self {
             Edition::Edition2015 => true,

src/librustdoc/config.rs

@@ -777,7 +777,9 @@ impl Options {
             }
         }
 
-        let edition = config::parse_crate_edition(early_dcx, matches);
+        // We don't want rustdoc invocations to complain about the lack of `--edition`.
+        let has_input = false;
+        let edition = config::parse_crate_edition(early_dcx, matches, has_input);
 
         let mut id_map = html::markdown::IdMap::new();
         let Some(external_html) = ExternalHtml::load(

src/tools/compiletest/src/directives.rs

@@ -405,11 +405,10 @@ impl TestProps {
             }
         }
 
-        if let Some(edition) = self.edition.or(config.edition) {
-            // The edition is added at the start, since flags from //@compile-flags must be passed
-            // to rustc last.
-            self.compile_flags.insert(0, format!("--edition={edition}"));
-        }
+        let edition = self.edition.or(config.edition).unwrap_or(Edition::Year(2015));
+        // The edition is added at the start, since flags from //@compile-flags must be passed
+        // to rustc last.
+        self.compile_flags.insert(0, format!("--edition={edition}"));
     }
 
     fn update_pass_fail_mode(&mut self, ln: &DirectiveLine<'_>, config: &Config) {

src/tools/compiletest/src/rustdoc_gui_test.rs

@@ -33,7 +33,10 @@ impl RustdocGuiTestProps {
 
         let props = TestProps::from_file(test_file_path, None, &config);
 
-        let TestProps { compile_flags, run_flags, .. } = props;
+        let TestProps { mut compile_flags, run_flags, .. } = props;
+        // We don't want to pass `--edition=2015` in, which is being set by default by
+        // `TestProps::from_file`.
+        compile_flags.remove(0);
         Self { compile_flags, run_flags }
     }
 }

tests/run-make/broken-pipe-no-ice/rmake.rs

@@ -68,7 +68,7 @@ fn check_broken_pipe_handled_gracefully(bin: Binary, mut cmd: Command) {
 
 fn main() {
     let mut rustc = bare_rustc();
-    rustc.arg("--print=sysroot");
+    rustc.arg("--print=sysroot").edition("2015");
     let rustc = rustc.into_raw_command();
     check_broken_pipe_handled_gracefully(Binary::Rustc, rustc);
 

tests/run-make/compressed-debuginfo/rmake.rs

@@ -12,6 +12,7 @@ use run_make_support::{assert_contains, llvm_readobj, run_in_tmpdir, rustc};
 fn check_compression(compression: &str, to_find: &str) {
     run_in_tmpdir(|| {
         let out = rustc()
+            .edition("2015")
             .crate_name("foo")
             .crate_type("lib")
             .emit("obj")

tests/run-make/const-destruct-stable-toolchain/rmake.rs

@@ -11,13 +11,15 @@ use run_make_support::{diff, rustc};
 fn main() {
     let out = rustc()
         .input("const-drop.rs")
+        .edition("2015")
         .env("RUSTC_BOOTSTRAP", "-1")
         .run_fail()
         .assert_stderr_not_contains("consider restricting type parameter `T`")
         .stderr_utf8();
     diff().expected_file("const-drop-stable.stderr").actual_text("(rustc)", &out).run();
     let out = rustc()
         .input("const-drop.rs")
+        .edition("2015")
         .ui_testing()
         .run_fail()
         .assert_stderr_contains(

tests/run-make/const-trait-stable-toolchain/rmake.rs

@@ -9,6 +9,7 @@ use run_make_support::{diff, rustc};
 
 fn main() {
     let out = rustc()
+        .edition("2015")
         .input("const-super-trait.rs")
         .env("RUSTC_BOOTSTRAP", "-1")
         .cfg("feature_enabled")
@@ -24,6 +25,7 @@ fn main() {
         .actual_text("(rustc)", &out)
         .run();
     let out = rustc()
+        .edition("2015")
         .input("const-super-trait.rs")
         .cfg("feature_enabled")
         .ui_testing()
@@ -36,6 +38,7 @@ fn main() {
         .actual_text("(rustc)", &out)
         .run();
     let out = rustc()
+        .edition("2015")
         .input("const-super-trait.rs")
         .env("RUSTC_BOOTSTRAP", "-1")
         .run_fail()
@@ -47,6 +50,7 @@ fn main() {
         .actual_text("(rustc)", &out)
         .run();
     let out = rustc()
+        .edition("2015")
         .input("const-super-trait.rs")
         .ui_testing()
         .run_fail()

tests/run-make/crate-loading-crate-depends-on-itself/rmake.rs

@@ -10,9 +10,10 @@
 use run_make_support::{diff, rust_lib_name, rustc};
 
 fn main() {
-    rustc().input("foo-prev.rs").run();
+    rustc().edition("2015").input("foo-prev.rs").run();
 
     let out = rustc()
+        .edition("2015")
         .extra_filename("current")
         .metadata("current")
         .input("foo-current.rs")

tests/run-make/crate-loading-multiple-candidates/rmake.rs

@@ -9,8 +9,18 @@ use run_make_support::{bare_rustc, diff, rfs, rustc};
 fn main() {
     // Check that relative paths are preserved in the diagnostic
     rfs::create_dir("mylibs");
-    rustc().input("crateresolve1-1.rs").out_dir("mylibs").extra_filename("-1").run();
-    rustc().input("crateresolve1-2.rs").out_dir("mylibs").extra_filename("-2").run();
+    rustc()
+        .edition("2015")
+        .input("crateresolve1-1.rs")
+        .out_dir("mylibs")
+        .extra_filename("-1")
+        .run();
+    rustc()
+        .edition("2015")
+        .input("crateresolve1-2.rs")
+        .out_dir("mylibs")
+        .extra_filename("-2")
+        .run();
     check("./mylibs");
 
     // Check that symlinks aren't followed when printing the diagnostic
@@ -21,6 +31,7 @@ fn main() {
 
 fn check(library_path: &str) {
     let out = rustc()
+        .edition("2015")
         .input("multiple-candidates.rs")
         .library_search_path(library_path)
         .ui_testing()

tests/run-make/crate-loading/rmake.rs

@@ -6,11 +6,16 @@
 use run_make_support::{diff, rust_lib_name, rustc};
 
 fn main() {
-    rustc().input("dependency-1.rs").run();
-    rustc().input("dependency-2.rs").extra_filename("2").metadata("2").run();
-    rustc().input("dep-2-reexport.rs").extern_("dependency", rust_lib_name("dependency2")).run();
+    rustc().edition("2015").input("dependency-1.rs").run();
+    rustc().edition("2015").input("dependency-2.rs").extra_filename("2").metadata("2").run();
+    rustc()
+        .edition("2015")
+        .input("dep-2-reexport.rs")
+        .extern_("dependency", rust_lib_name("dependency2"))
+        .run();
 
     let out = rustc()
+        .edition("2015")
         .input("multiple-dep-versions.rs")
         .extern_("dependency", rust_lib_name("dependency"))
         .extern_("dep_2_reexport", rust_lib_name("foo"))

tests/run-make/emit-to-stdout/rmake.rs

@@ -13,8 +13,9 @@ use run_make_support::{diff, run_in_tmpdir, rustc};
 
 // Test emitting text outputs to stdout works correctly
 fn run_diff(name: &str, file_args: &[&str]) {
-    rustc().emit(format!("{name}={name}")).input("test.rs").args(file_args).run();
-    let out = rustc().emit(format!("{name}=-")).input("test.rs").run().stdout_utf8();
+    rustc().edition("2015").emit(format!("{name}={name}")).input("test.rs").args(file_args).run();
+    let out =
+        rustc().edition("2015").emit(format!("{name}=-")).input("test.rs").run().stdout_utf8();
     diff().expected_file(name).actual_text("stdout", &out).run();
 }
 
@@ -29,7 +30,13 @@ fn run_terminal_err_diff(name: &str) {
     let terminal = File::options().read(true).write(true).open(r"\\.\CONOUT$").unwrap();
 
     let err = File::create(name).unwrap();
-    rustc().emit(format!("{name}=-")).input("test.rs").stdout(terminal).stderr(err).run_fail();
+    rustc()
+        .edition("2015")
+        .emit(format!("{name}=-"))
+        .input("test.rs")
+        .stdout(terminal)
+        .stderr(err)
+        .run_fail();
     diff().expected_file(format!("emit-{name}.stderr")).actual_file(name).run();
 }
 
@@ -47,6 +54,7 @@ fn main() {
 
         // Test error for emitting multiple types to stdout
         rustc()
+            .edition("2015")
             .input("test.rs")
             .emit("asm=-")
             .emit("llvm-ir=-")
@@ -58,6 +66,7 @@ fn main() {
 
         // Same as above, but using `-o`
         rustc()
+            .edition("2015")
             .input("test.rs")
             .output("-")
             .emit("asm,llvm-ir,dep-info,mir")
@@ -69,6 +78,11 @@ fn main() {
             .run();
 
         // Test that `-o -` redirected to a file works correctly (#26719)
-        rustc().input("test.rs").output("-").stdout(File::create("out-stdout").unwrap()).run();
+        rustc()
+            .edition("2015")
+            .input("test.rs")
+            .output("-")
+            .stdout(File::create("out-stdout").unwrap())
+            .run();
     });
 }