implement range support in //@ edition

Author: pietroalbini

src/tools/compiletest/src/directives.rs

@@ -432,10 +432,11 @@ impl TestProps {
                         panic!("`compiler-flags` directive should be spelled `compile-flags`");
                     }
 
-                    if let Some(edition) = config.parse_edition(ln, testfile, line_number) {
+                    if let Some(range) = parse_edition_range(config, ln, testfile, line_number) {
                         // 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.trim()));
+                        self.compile_flags
+                            .insert(0, format!("--edition={}", range.edition_to_test(config)));
                         has_edition = true;
                     }
 
@@ -1125,10 +1126,6 @@ impl Config {
         }
     }
 
-    fn parse_edition(&self, line: &str, testfile: &Utf8Path, line_number: usize) -> Option<String> {
-        self.parse_name_value_directive(line, "edition", testfile, line_number)
-    }
-
     fn set_name_directive(&self, line: &str, directive: &str, value: &mut bool) {
         match value {
             true => {
@@ -1784,3 +1781,103 @@ enum IgnoreDecision {
     Continue,
     Error { message: String },
 }
+
+fn parse_edition_range(
+    config: &Config,
+    line: &str,
+    testfile: &Utf8Path,
+    line_number: usize,
+) -> Option<EditionRange> {
+    let raw = config.parse_name_value_directive(line, "edition", testfile, line_number)?;
+
+    if let Some((greter_equal_than, lower_than)) = raw.split_once("..") {
+        Some(match (maybe_parse_edition(greter_equal_than), maybe_parse_edition(lower_than)) {
+            (Some(greater_equal_than), Some(lower_than)) if lower_than < greater_equal_than => {
+                panic!("the left side of `//@ edition` cannot be higher than the right side");
+            }
+            (Some(greater_equal_than), Some(lower_than)) if lower_than == greater_equal_than => {
+                panic!("the left side of `//@ edition` cannot be equal to the right side");
+            }
+            (Some(greater_equal_than), Some(lower_than)) => {
+                EditionRange::Range { greater_equal_than, lower_than }
+            }
+            (Some(greater_equal_than), None) => EditionRange::GreaterEqualThan(greater_equal_than),
+            (None, Some(_)) => panic!("..edition is not a supported range in //@ edition"),
+            (None, None) => panic!("'..' is not a supported range in //@ edition"),
+        })
+    } else {
+        Some(EditionRange::Exact(maybe_parse_edition(&raw).expect("empty value for //@ edition")))
+    }
+}
+
+fn maybe_parse_edition(mut input: &str) -> Option<Edition> {
+    input = input.trim();
+    if input.is_empty() {
+        return None;
+    }
+    Some(parse_edition(input))
+}
+
+fn parse_edition(mut input: &str) -> Edition {
+    input = input.trim();
+    if input == "future" {
+        Edition::Future
+    } else {
+        Edition::Year(input.parse().expect(&format!("'{input}' doesn't look like an edition")))
+    }
+}
+
+#[derive(Debug, Copy, Clone, PartialEq, Eq, PartialOrd, Ord)]
+enum Edition {
+    // Note that the ordering here is load-bearing, as we want the future edition to be last.
+    Year(u32),
+    Future,
+}
+
+impl std::fmt::Display for Edition {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Edition::Year(year) => write!(f, "{year}"),
+            Edition::Future => f.write_str("future"),
+        }
+    }
+}
+
+impl From<u32> for Edition {
+    fn from(value: u32) -> Self {
+        Edition::Year(value)
+    }
+}
+
+#[derive(Debug, PartialEq, Eq, Clone, Copy)]
+enum EditionRange {
+    Exact(Edition),
+    GreaterEqualThan(Edition),
+    Range { greater_equal_than: Edition, lower_than: Edition },
+}
+
+impl EditionRange {
+    fn edition_to_test(&self, config: &Config) -> Edition {
+        let min_edition = Edition::Year(2015);
+        let requested: Edition =
+            config.edition.as_deref().map(parse_edition).unwrap_or(min_edition);
+
+        match *self {
+            EditionRange::Exact(exact) => exact,
+            EditionRange::GreaterEqualThan(greater_equal_than) => {
+                if requested >= greater_equal_than {
+                    requested
+                } else {
+                    greater_equal_than // Lower bound
+                }
+            }
+            EditionRange::Range { greater_equal_than, lower_than } => {
+                if requested >= greater_equal_than && requested < lower_than {
+                    requested
+                } else {
+                    greater_equal_than // Lower bound
+                }
+            }
+        }
+    }
+}

src/tools/compiletest/src/directives/tests.rs

@@ -4,8 +4,8 @@ use camino::Utf8Path;
 use semver::Version;
 
 use super::{
-    DirectivesCache, EarlyProps, extract_llvm_version, extract_version_range, iter_directives,
-    parse_normalize_rule,
+    DirectivesCache, EarlyProps, Edition, EditionRange, extract_llvm_version,
+    extract_version_range, iter_directives, parse_normalize_rule,
 };
 use crate::common::{Config, Debugger, TestMode};
 use crate::executor::{CollectedTestDesc, ShouldPanic};
@@ -71,6 +71,7 @@ fn test_parse_normalize_rule() {
 struct ConfigBuilder {
     mode: Option<String>,
     channel: Option<String>,
+    edition: Option<String>,
     host: Option<String>,
     target: Option<String>,
     stage: Option<u32>,
@@ -94,6 +95,11 @@ impl ConfigBuilder {
         self
     }
 
+    fn edition(&mut self, s: &str) -> &mut Self {
+        self.edition = Some(s.to_owned());
+        self
+    }
+
     fn host(&mut self, s: &str) -> &mut Self {
         self.host = Some(s.to_owned());
         self
@@ -181,6 +187,10 @@ impl ConfigBuilder {
         ];
         let mut args: Vec<String> = args.iter().map(ToString::to_string).collect();
 
+        if let Some(edition) = &self.edition {
+            args.push(format!("--edition={edition}"));
+        }
+
         if let Some(ref llvm_version) = self.llvm_version {
             args.push("--llvm-version".to_owned());
             args.push(llvm_version.clone());
@@ -939,3 +949,138 @@ fn test_needs_target_std() {
     let config = cfg().target("x86_64-unknown-linux-gnu").build();
     assert!(!check_ignore(&config, "//@ needs-target-std"));
 }
+
+fn y(year: u32) -> Edition {
+    Edition::Year(year)
+}
+
+fn parse_edition_range(line: &str) -> Option<EditionRange> {
+    let config = cfg().build();
+    super::parse_edition_range(&config, line, "tmp.rs".into(), 0)
+}
+
+#[test]
+fn test_parse_edition_range() {
+    assert_eq!(None, parse_edition_range("hello-world"));
+    assert_eq!(None, parse_edition_range("edition"));
+
+    assert_eq!(Some(EditionRange::Exact(y(2018))), parse_edition_range("edition: 2018"));
+    assert_eq!(Some(EditionRange::Exact(y(2021))), parse_edition_range("edition:2021"));
+    assert_eq!(Some(EditionRange::Exact(y(2024))), parse_edition_range("edition: 2024 "));
+    assert_eq!(Some(EditionRange::Exact(Edition::Future)), parse_edition_range("edition: future"));
+
+    assert_eq!(
+        Some(EditionRange::GreaterEqualThan(y(2018))),
+        parse_edition_range("edition: 2018..")
+    );
+    assert_eq!(
+        Some(EditionRange::GreaterEqualThan(y(2021))),
+        parse_edition_range("edition:2021 ..")
+    );
+    assert_eq!(
+        Some(EditionRange::GreaterEqualThan(y(2024))),
+        parse_edition_range("edition: 2024 .. ")
+    );
+    assert_eq!(
+        Some(EditionRange::GreaterEqualThan(Edition::Future)),
+        parse_edition_range("edition: future.. ")
+    );
+
+    assert_eq!(
+        Some(EditionRange::Range { greater_equal_than: y(2018), lower_than: y(2024) }),
+        parse_edition_range("edition: 2018..2024")
+    );
+    assert_eq!(
+        Some(EditionRange::Range { greater_equal_than: y(2015), lower_than: y(2021) }),
+        parse_edition_range("edition:2015 .. 2021 ")
+    );
+    assert_eq!(
+        Some(EditionRange::Range { greater_equal_than: y(2021), lower_than: y(2027) }),
+        parse_edition_range("edition: 2021 .. 2027 ")
+    );
+    assert_eq!(
+        Some(EditionRange::Range { greater_equal_than: y(2021), lower_than: Edition::Future }),
+        parse_edition_range("edition: 2021..future")
+    );
+}
+
+#[test]
+#[should_panic = "empty directive value detected"]
+fn test_parse_edition_range_empty() {
+    parse_edition_range("edition:");
+}
+
+#[test]
+#[should_panic = "'hello' doesn't look like an edition"]
+fn test_parse_edition_range_invalid_edition() {
+    parse_edition_range("edition: hello");
+}
+
+#[test]
+#[should_panic = "'..' is not a supported range in //@ edition"]
+fn test_parse_edition_range_double_dots() {
+    parse_edition_range("edition: ..");
+}
+
+#[test]
+#[should_panic = "the left side of `//@ edition` cannot be higher than the right side"]
+fn test_parse_edition_range_inverted_range() {
+    parse_edition_range("edition: 2021..2015");
+}
+
+#[test]
+#[should_panic = "the left side of `//@ edition` cannot be higher than the right side"]
+fn test_parse_edition_range_inverted_range_future() {
+    parse_edition_range("edition: future..2015");
+}
+
+#[test]
+#[should_panic = "the left side of `//@ edition` cannot be equal to the right side"]
+fn test_parse_edition_range_empty_range() {
+    parse_edition_range("edition: 2021..2021");
+}
+
+#[track_caller]
+fn assert_edition_to_test(
+    expected: impl Into<Edition>,
+    range: EditionRange,
+    default: Option<&str>,
+) {
+    let mut cfg = cfg();
+    if let Some(default) = default {
+        cfg.edition(default);
+    }
+    assert_eq!(expected.into(), range.edition_to_test(&cfg.build()));
+}
+
+#[test]
+fn test_edition_range_edition_to_test() {
+    let exact = EditionRange::Exact(y(2021));
+    assert_edition_to_test(2021, exact, None);
+    assert_edition_to_test(2021, exact, Some("2018"));
+    assert_edition_to_test(2021, exact, Some("future"));
+
+    assert_edition_to_test(Edition::Future, EditionRange::Exact(Edition::Future), None);
+
+    let greater_equal_than = EditionRange::GreaterEqualThan(y(2021));
+    assert_edition_to_test(2021, greater_equal_than, None);
+    assert_edition_to_test(2021, greater_equal_than, Some("2015"));
+    assert_edition_to_test(2021, greater_equal_than, Some("2018"));
+    assert_edition_to_test(2021, greater_equal_than, Some("2021"));
+    assert_edition_to_test(2024, greater_equal_than, Some("2024"));
+    assert_edition_to_test(Edition::Future, greater_equal_than, Some("future"));
+
+    let range = EditionRange::Range { greater_equal_than: y(2018), lower_than: y(2024) };
+    assert_edition_to_test(2018, range, None);
+    assert_edition_to_test(2018, range, Some("2015"));
+    assert_edition_to_test(2018, range, Some("2018"));
+    assert_edition_to_test(2021, range, Some("2021"));
+    assert_edition_to_test(2018, range, Some("2024"));
+    assert_edition_to_test(2018, range, Some("future"));
+}
+
+#[test]
+#[should_panic = "'not an edition' doesn't look like an edition"]
+fn test_edition_range_edition_to_test_bad_cli() {
+    assert_edition_to_test(2021, EditionRange::Exact(y(2021)), Some("not an edition"));
+}