Add new configuration option abort_on_unrecognised_options

This option was proposed in issue 5022 and allows rustfmt to exit early
in the event that any unstable options are used while using stable
rustfmt.

Author: ytmimi

Configurations.md

@@ -17,6 +17,15 @@ To enable unstable options, set `unstable_features = true` in `rustfmt.toml` or
 
 Below you find a detailed visual guide on all the supported configuration options of rustfmt:
 
+## `abort_on_unrecognised_options`
+
+Exit early when using nightly only options on the stable channel
+
+- **Default value**: `false`
+- **Possible values**: `true`, `false`
+- **Stable**: No (tracking issue: [#5022](https://github.com/rust-lang/rustfmt/issues/5022))
+
+
 ## `array_width`
 
 Maximum width of an array literal before falling back to vertical formatting.

src/bin/main.rs

@@ -302,6 +302,7 @@ fn format(
     }
 
     let out = &mut stdout();
+
     let mut session = Session::new(config, Some(out));
 
     for file in files {

src/config/config_type.rs

@@ -1,3 +1,5 @@
+use std::collections::HashMap;
+
 use crate::config::file_lines::FileLines;
 use crate::config::options::{IgnoreList, WidthHeuristics};
 
@@ -50,6 +52,78 @@ impl ConfigType for IgnoreList {
     }
 }
 
+/// Store a map of all Unstable options used in in the configuration.
+#[derive(Clone, Debug)]
+pub struct UnstableOptions {
+    options: HashMap<&'static str, String>,
+}
+
+impl UnstableOptions {
+    /// Create a new UnstableOptions struct
+    pub(crate) fn new() -> Self {
+        Self {
+            options: HashMap::new(),
+        }
+    }
+
+    /// Insert an unstable option and a user supplied value for that unstable option
+    pub(crate) fn insert(&mut self, option: &'static str, user_supplied_value: String) {
+        self.options.insert(option, user_supplied_value);
+    }
+
+    /// Check if any unstable options have been set
+    pub(crate) fn has_unstable_options(&self) -> bool {
+        !self.options.is_empty()
+    }
+
+    // primarily used for testing
+    #[allow(dead_code)]
+    pub(crate) fn options(&self) -> &HashMap<&'static str, String> {
+        &self.options
+    }
+
+    /// Generate the Warning message
+    pub fn warning_message(&self) -> Option<String> {
+        if self.options.is_empty() {
+            return None;
+        }
+        let mut result = String::new();
+
+        for (k, v) in self.options.iter() {
+            result.push_str(&format!(
+                "Warning: can't set `{} = {}`, unstable features are only \
+                    available in nightly channel.\n",
+                k, v,
+            ));
+        }
+
+        let upgrade_to_abort_message = "\nSet `abort_on_unrecognised_options = true` \
+        to convert this warning into an error\n\n";
+
+        result.push_str(upgrade_to_abort_message);
+
+        Some(result)
+    }
+
+    /// Generate the Abort message
+    pub fn abort_message(&self) -> Option<String> {
+        if self.options.is_empty() {
+            return None;
+        }
+
+        let mut result = String::new();
+        result.push_str("Can't set nightly options when using stable rustfmt\n");
+
+        for (k, v) in self.options.iter() {
+            result.push_str(&format!("    - `{} = {}`\n", k, v));
+        }
+        let to_warning_message = "\nSet `abort_on_unrecognised_options = false` \
+        to convert this error into a warning\n\n";
+        result.push_str(to_warning_message);
+        Some(result)
+    }
+}
+
 macro_rules! create_config {
     ($($i:ident: $ty:ty, $def:expr, $stb:expr, $( $dstring:expr ),+ );+ $(;)*) => (
         #[cfg(test)]
@@ -64,6 +138,8 @@ macro_rules! create_config {
             // if a license_template_path has been specified, successfully read, parsed and compiled
             // into a regex, it will be stored here
             pub license_template: Option<Regex>,
+            // Unstable Options specified on the stable channel
+            configured_unstable_options: UnstableOptions,
             // For each config item, we store a bool indicating whether it has
             // been accessed and the value, and a bool whether the option was
             // manually initialised, or taken from the default,
@@ -145,21 +221,35 @@ macro_rules! create_config {
                 ConfigWasSet(self)
             }
 
+            /// Insert all unstable options and their values into the UnstableOptions struct.
+            /// The only exception is the "abort_on_unrecognised_options", which helps
+            /// determine if we should abort or warn when using unstable options on stable rustfmt
+            #[allow(unreachable_pub)]
+            pub fn insert_unstable_options(&mut self, option: &'static str, value: String) {
+                if option == "abort_on_unrecognised_options" {
+                   return
+                }
+
+                match option {
+                $(
+                    stringify!($i) => {
+                        // If its an unstable option then add it to the unstable list
+                        if !self.$i.3 {
+                            self.configured_unstable_options.insert(option, value);
+                        }
+                    }
+                )+
+                    _ => panic!("Unknown config key in override: {}", option)
+                }
+
+            }
+
             fn fill_from_parsed_config(mut self, parsed: PartialConfig, dir: &Path) -> Config {
             $(
                 if let Some(val) = parsed.$i {
-                    if self.$i.3 {
-                        self.$i.1 = true;
-                        self.$i.2 = val;
-                    } else {
-                        if crate::is_nightly_channel!() {
-                            self.$i.1 = true;
-                            self.$i.2 = val;
-                        } else {
-                            eprintln!("Warning: can't set `{} = {:?}`, unstable features are only \
-                                       available in nightly channel.", stringify!($i), val);
-                        }
-                    }
+                    self.insert_unstable_options(stringify!($i), format!("{:?}", &val));
+                    self.$i.1 = true;
+                    self.$i.2 = val;
                 }
             )+
                 self.set_heuristics();
@@ -220,6 +310,12 @@ macro_rules! create_config {
                 }
             }
 
+            /// Get a reference to the UnstableOptions set on the configuration.
+            #[allow(unreachable_pub)]
+            pub fn unstable_options(&self) -> &UnstableOptions {
+                &self.configured_unstable_options
+            }
+
             #[allow(unreachable_pub)]
             pub fn override_value(&mut self, key: &str, val: &str)
             {
@@ -232,6 +328,7 @@ macro_rules! create_config {
                                                  stringify!($i),
                                                  val,
                                                  stringify!($ty)));
+                            self.insert_unstable_options(stringify!($i), val.to_owned());
                         }
                     )+
                     _ => panic!("Unknown config key in override: {}", key)
@@ -438,6 +535,7 @@ macro_rules! create_config {
             fn default() -> Config {
                 Config {
                     license_template: None,
+                    configured_unstable_options: UnstableOptions::new(),
                     $(
                         $i: (Cell::new(false), false, $def, $stb),
                     )+