tidy: forbid since values for features that point to the current release or future ones

It's a common phenomenon that feature stabilizations don't make it into
a particular release, but the version is still inaccurate. Often this
leads to subsequent changes to adjust/correct the version.

Instead, require people to put a placeholder that gets replaced during
beta branching time with the current rust version. That way, there is
no chance that an error can be introduced.

Usage of the placeholder is required on the nightly channel, and forbidden
on the stable and beta channels.

Author: est31

src/tools/tidy/src/features.rs

@@ -175,6 +175,36 @@ pub fn check(
         tidy_error!(bad, "Found {} features without a gate test.", gate_untested.len());
     }
 
+    let (version, channel) = get_version_and_channel(src_path);
+
+    let all_features_iter = features
+        .iter()
+        .map(|feat| (feat, "lang"))
+        .chain(lib_features.iter().map(|feat| (feat, "lib")));
+    for ((feature_name, feature), kind) in all_features_iter {
+        let since = if let Some(since) = feature.since { since } else { continue };
+        if since > version && since != Version::CurrentPlaceholder {
+            tidy_error!(
+                bad,
+                "The stabilization version {since} of {kind} feature `{feature_name}` is newer than the current {version}"
+            );
+        }
+        if channel == "nightly" && since == version {
+            tidy_error!(
+                bad,
+                "The stabilization version {since} of {kind} feature `{feature_name}` is written out but should be {}",
+                version::VERSION_PLACEHOLDER
+            );
+        }
+        if channel != "nightly" && since == Version::CurrentPlaceholder {
+            tidy_error!(
+                bad,
+                "The placeholder use of {kind} feature `{feature_name}` is not allowed on the {} channel",
+                version::VERSION_PLACEHOLDER
+            );
+        }
+    }
+
     if *bad {
         return CollectedFeatures { lib: lib_features, lang: features };
     }
@@ -195,6 +225,14 @@ pub fn check(
     CollectedFeatures { lib: lib_features, lang: features }
 }
 
+fn get_version_and_channel(src_path: &Path) -> (Version, String) {
+    let version_str = t!(std::fs::read_to_string(src_path.join("version")));
+    let version_str = version_str.trim();
+    let version = t!(std::str::FromStr::from_str(&version_str).map_err(|e| format!("{e:?}")));
+    let channel_str = t!(std::fs::read_to_string(src_path.join("ci").join("channel")));
+    (version, channel_str.trim().to_owned())
+}
+
 fn format_features<'a>(
     features: &'a Features,
     family: &'a str,

src/tools/tidy/src/features/version.rs

@@ -5,14 +5,22 @@ use std::str::FromStr;
 #[cfg(test)]
 mod tests;
 
+pub const VERSION_PLACEHOLDER: &str = "CURRENT_RUSTC_VERSION";
+
 #[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
-pub struct Version {
-    parts: [u32; 3],
+pub enum Version {
+    Explicit { parts: [u32; 3] },
+    CurrentPlaceholder,
 }
 
 impl fmt::Display for Version {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        f.pad(&format!("{}.{}.{}", self.parts[0], self.parts[1], self.parts[2]))
+        match self {
+            Version::Explicit { parts } => {
+                f.pad(&format!("{}.{}.{}", parts[0], parts[1], parts[2]))
+            }
+            Version::CurrentPlaceholder => f.pad(&format!("CURRENT")),
+        }
     }
 }
 
@@ -32,6 +40,9 @@ impl FromStr for Version {
     type Err = ParseVersionError;
 
     fn from_str(s: &str) -> Result<Self, Self::Err> {
+        if s == VERSION_PLACEHOLDER {
+            return Ok(Version::CurrentPlaceholder);
+        }
         let mut iter = s.split('.').map(|part| Ok(part.parse()?));
 
         let mut part = || iter.next().unwrap_or(Err(ParseVersionError::WrongNumberOfParts));
@@ -43,6 +54,6 @@ impl FromStr for Version {
             return Err(ParseVersionError::WrongNumberOfParts);
         }
 
-        Ok(Self { parts })
+        Ok(Version::Explicit { parts })
     }
 }

src/tools/tidy/src/lib.rs

@@ -28,7 +28,8 @@ macro_rules! t {
 macro_rules! tidy_error {
     ($bad:expr, $fmt:expr) => ({
         *$bad = true;
-        eprintln!("tidy error: {}", $fmt);
+        eprint!("tidy error: ");
+        eprintln!($fmt);
     });
     ($bad:expr, $fmt:expr, $($arg:tt)*) => ({
         *$bad = true;