Address review comments

Author: pvdrz

src/tools/compiletest/src/directives.rs

@@ -18,8 +18,8 @@ use crate::directives::directive_names::{
 use crate::directives::needs::CachedNeedsConditions;
 use crate::errors::ErrorKind;
 use crate::executor::{CollectedTestDesc, ShouldPanic};
-use crate::help;
 use crate::util::static_regex;
+use crate::{fatal, help};
 
 pub(crate) mod auxiliary;
 mod cfg;
@@ -1790,23 +1790,35 @@ fn parse_edition_range(
 ) -> 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 => {
+    // Edition range is half-open: `[lower_bound, upper_bound)`
+    if let Some((lower_bound, upper_bound)) = raw.split_once("..") {
+        Some(match (maybe_parse_edition(lower_bound), maybe_parse_edition(upper_bound)) {
+            (Some(lower_bound), Some(upper_bound)) if upper_bound < lower_bound => {
                 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 => {
+            (Some(lower_bound), Some(upper_bound)) if upper_bound == lower_bound => {
                 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(lower_bound), Some(upper_bound)) => {
+                EditionRange::Range { lower_bound, upper_bound }
+            }
+            (Some(lower_bound), None) => EditionRange::RangeFrom(lower_bound),
+            (None, Some(_)) => {
+                fatal!(
+                    "{testfile}:{line_number}: ..edition is not a supported range in //@ edition"
+                );
+            }
+            (None, None) => {
+                fatal!("{testfile}:{line_number}: '..' is not a supported range in //@ edition");
             }
-            (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")))
+        match maybe_parse_edition(&raw) {
+            Some(edition) => Some(EditionRange::Exact(edition)),
+            None => {
+                fatal!("{testfile}:{line_number}: empty value for //@ edition");
+            }
+        }
     }
 }
 
@@ -1852,8 +1864,12 @@ impl From<u32> for Edition {
 #[derive(Debug, PartialEq, Eq, Clone, Copy)]
 enum EditionRange {
     Exact(Edition),
-    GreaterEqualThan(Edition),
-    Range { greater_equal_than: Edition, lower_than: Edition },
+    RangeFrom(Edition),
+    /// Half-open range: `[lower_bound, upper_bound)`
+    Range {
+        lower_bound: Edition,
+        upper_bound: Edition,
+    },
 }
 
 impl EditionRange {
@@ -1864,18 +1880,18 @@ impl EditionRange {
 
         match *self {
             EditionRange::Exact(exact) => exact,
-            EditionRange::GreaterEqualThan(greater_equal_than) => {
-                if requested >= greater_equal_than {
+            EditionRange::RangeFrom(lower_bound) => {
+                if requested >= lower_bound {
                     requested
                 } else {
-                    greater_equal_than // Lower bound
+                    lower_bound
                 }
             }
-            EditionRange::Range { greater_equal_than, lower_than } => {
-                if requested >= greater_equal_than && requested < lower_than {
+            EditionRange::Range { lower_bound, upper_bound } => {
+                if requested >= lower_bound && requested < upper_bound {
                     requested
                 } else {
-                    greater_equal_than // Lower bound
+                    lower_bound
                 }
             }
         }

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

@@ -969,73 +969,64 @@ fn test_parse_edition_range() {
     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::RangeFrom(y(2018))), parse_edition_range("edition: 2018.."));
+    assert_eq!(Some(EditionRange::RangeFrom(y(2021))), parse_edition_range("edition:2021 .."));
+    assert_eq!(Some(EditionRange::RangeFrom(y(2024))), parse_edition_range("edition: 2024 .. "));
     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)),
+        Some(EditionRange::RangeFrom(Edition::Future)),
         parse_edition_range("edition: future.. ")
     );
 
     assert_eq!(
-        Some(EditionRange::Range { greater_equal_than: y(2018), lower_than: y(2024) }),
+        Some(EditionRange::Range { lower_bound: y(2018), upper_bound: y(2024) }),
         parse_edition_range("edition: 2018..2024")
     );
     assert_eq!(
-        Some(EditionRange::Range { greater_equal_than: y(2015), lower_than: y(2021) }),
+        Some(EditionRange::Range { lower_bound: y(2015), upper_bound: y(2021) }),
         parse_edition_range("edition:2015 .. 2021 ")
     );
     assert_eq!(
-        Some(EditionRange::Range { greater_equal_than: y(2021), lower_than: y(2027) }),
+        Some(EditionRange::Range { lower_bound: y(2021), upper_bound: y(2027) }),
         parse_edition_range("edition: 2021 .. 2027 ")
     );
     assert_eq!(
-        Some(EditionRange::Range { greater_equal_than: y(2021), lower_than: Edition::Future }),
+        Some(EditionRange::Range { lower_bound: y(2021), upper_bound: Edition::Future }),
         parse_edition_range("edition: 2021..future")
     );
 }
 
 #[test]
-#[should_panic = "empty directive value detected"]
+#[should_panic]
 fn test_parse_edition_range_empty() {
     parse_edition_range("edition:");
 }
 
 #[test]
-#[should_panic = "'hello' doesn't look like an edition"]
+#[should_panic]
 fn test_parse_edition_range_invalid_edition() {
     parse_edition_range("edition: hello");
 }
 
 #[test]
-#[should_panic = "'..' is not a supported range in //@ edition"]
+#[should_panic]
 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"]
+#[should_panic]
 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"]
+#[should_panic]
 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"]
+#[should_panic]
 fn test_parse_edition_range_empty_range() {
     parse_edition_range("edition: 2021..2021");
 }
@@ -1062,15 +1053,15 @@ fn test_edition_range_edition_to_test() {
 
     assert_edition_to_test(Edition::Future, EditionRange::Exact(Edition::Future), None);
 
-    let greater_equal_than = EditionRange::GreaterEqualThan(y(2021));
+    let greater_equal_than = EditionRange::RangeFrom(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) };
+    let range = EditionRange::Range { lower_bound: y(2018), upper_bound: 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"));
@@ -1080,7 +1071,7 @@ fn test_edition_range_edition_to_test() {
 }
 
 #[test]
-#[should_panic = "'not an edition' doesn't look like an edition"]
+#[should_panic]
 fn test_edition_range_edition_to_test_bad_cli() {
     assert_edition_to_test(2021, EditionRange::Exact(y(2021)), Some("not an edition"));
 }