Add new configuration option abort_on_unrecognised_options

ytmimi · ytmimi · commit 3b4c02fcc43d · 2022-01-04T09:07:30.000-05:00
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.
diff --git a/Configurations.md b/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.
diff --git a/src/config/config_type.rs b/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,82 @@ impl ConfigType for IgnoreList {
     }
 }
 
+/// Store a map of all Unstable options used in in the configuration.
+#[derive(Clone, Debug)]
+pub struct UnstableOptions {
+    pub(crate) options: HashMap<&'static str, String>,
+}
+
+impl std::fmt::Display for UnstableOptions {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        if let Some(message) = self.abort_message() {
+            write!(f, "{}", message)
+        } else {
+            write!(f, "No unstable options were used.")
+        }
+    }
+}
+
+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()
+    }
+
+    /// Generate the Warning message
+    pub(crate) 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(crate) 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 +142,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 +225,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 +314,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 +332,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 +539,7 @@ macro_rules! create_config {
             fn default() -> Config {
                 Config {
                     license_template: None,
+                    configured_unstable_options: UnstableOptions::new(),
                     $(
                         $i: (Cell::new(false), false, $def, $stb),
                     )+
diff --git a/src/config/mod.rs b/src/config/mod.rs
@@ -10,6 +10,8 @@ use thiserror::Error;
 
 use crate::config::config_type::ConfigType;
 #[allow(unreachable_pub)]
+pub use crate::config::config_type::UnstableOptions;
+#[allow(unreachable_pub)]
 pub use crate::config::file_lines::{FileLines, FileName, Range};
 #[allow(unreachable_pub)]
 pub use crate::config::lists::*;
@@ -168,6 +170,8 @@ create_config! {
         "Report all, none or unnumbered occurrences of FIXME in source file comments";
     ignore: IgnoreList, IgnoreList::default(), false,
         "Skip formatting the specified files and directories";
+    abort_on_unrecognised_options: bool, false, false,
+        "Exit early when using nightly only options on the stable channel";
 
     // Not user-facing
     verbose: Verbosity, Verbosity::Normal, false, "How much to information to emit to the user";
@@ -403,6 +407,7 @@ fn config_path(options: &dyn CliOptions) -> Result<Option<PathBuf>, Error> {
 #[cfg(test)]
 mod test {
     use super::*;
+    use std::collections::HashMap;
     use std::str;
 
     use rustfmt_config_proc_macro::{nightly_only_test, stable_only_test};
@@ -545,6 +550,55 @@ mod test {
         assert!(config.license_template.is_none());
     }
 
+    #[test]
+    fn test_get_all_unstable_options_set_in_toml() {
+        let toml = r#"
+            reorder_impl_items = true
+        "#;
+        let config = Config::from_toml(toml, Path::new("")).unwrap();
+        let mut expected = HashMap::new();
+        expected.insert("reorder_impl_items", String::from("true"));
+        assert_eq!(config.unstable_options().options, expected);
+    }
+
+    #[test]
+    fn test_warning_message_when_using_unstable_options() {
+        let toml = r#"
+            reorder_impl_items = true
+        "#;
+        let config = Config::from_toml(toml, Path::new("")).unwrap();
+        let warning = "\
+Warning: can't set `reorder_impl_items = true`, unstable features are only available in \
+nightly channel.
+
+Set `abort_on_unrecognised_options = true` to convert this warning into an error
+
+";
+        assert_eq!(
+            warning,
+            config.unstable_options().warning_message().unwrap()
+        )
+    }
+
+    #[test]
+    fn test_abort_message_when_using_unstable_options() {
+        let toml = r#"
+            reorder_impl_items = true
+        "#;
+        let config = Config::from_toml(toml, Path::new("")).unwrap();
+        let abort_message = "\
+Can't set nightly options when using stable rustfmt
+    - `reorder_impl_items = true`
+
+Set `abort_on_unrecognised_options = false` to convert this error into a warning
+
+";
+        assert_eq!(
+            abort_message,
+            config.unstable_options().abort_message().unwrap()
+        )
+    }
+
     #[test]
     fn test_dump_default_config() {
         let default_config = format!(
@@ -623,6 +677,7 @@ error_on_unformatted = false
 report_todo = "Never"
 report_fixme = "Never"
 ignore = []
+abort_on_unrecognised_options = false
 emit_mode = "Files"
 make_backup = false
 "#,
diff --git a/src/format_report_formatter.rs b/src/format_report_formatter.rs
@@ -144,6 +144,7 @@ fn error_kind_to_snippet_annotation_type(error_kind: &ErrorKind) -> AnnotationTy
         | ErrorKind::LicenseCheck
         | ErrorKind::BadAttr
         | ErrorKind::InvalidGlobPattern(_)
+        | ErrorKind::NightlyOnlyOptions(_)
         | ErrorKind::VersionMismatch => AnnotationType::Error,
         ErrorKind::BadIssue(_) | ErrorKind::DeprecatedAttr => AnnotationType::Warning,
     }
diff --git a/src/formatting.rs b/src/formatting.rs
@@ -37,6 +37,20 @@ impl<'b, T: Write + 'b> Session<'b, T> {
             return Err(ErrorKind::VersionMismatch);
         }
 
+        if !crate::is_nightly_channel!() {
+            let using_unstalbe_options = self.config.unstable_options().has_unstable_options();
+            let abort_on_unstable_options = self.config.abort_on_unrecognised_options();
+            if using_unstalbe_options && abort_on_unstable_options {
+                return Err(ErrorKind::NightlyOnlyOptions(
+                    self.config.unstable_options().clone(),
+                ));
+            } else if using_unstalbe_options && !abort_on_unstable_options {
+                if let Some(warning) = self.config.unstable_options().warning_message() {
+                    eprintln!("{}", warning);
+                }
+            }
+        }
+
         rustc_span::create_session_if_not_set_then(self.config.edition().into(), |_| {
             if self.config.disable_all_formatting() {
                 // When the input is from stdin, echo back the input.
diff --git a/src/lib.rs b/src/lib.rs
@@ -47,7 +47,7 @@ use crate::utils::indent_next_line;
 
 pub use crate::config::{
     load_config, CliOptions, Color, Config, Edition, EmitMode, FileLines, FileName, NewlineStyle,
-    Range, Verbosity,
+    Range, UnstableOptions, Verbosity,
 };
 
 pub use crate::format_report_formatter::{FormatReportFormatter, FormatReportFormatterBuilder};
@@ -141,6 +141,9 @@ pub enum ErrorKind {
     /// Invalid glob pattern in `ignore` configuration option.
     #[error("Invalid glob pattern found in ignore list: {0}")]
     InvalidGlobPattern(ignore::Error),
+    /// Using unstable, nightly only options on stable rustfmt.
+    #[error("{0}")]
+    NightlyOnlyOptions(UnstableOptions),
 }
 
 impl ErrorKind {
diff --git a/tests/config/no_unstable_options.toml b/tests/config/no_unstable_options.toml
@@ -0,0 +1,3 @@
+max_width = 100
+hard_tabs = false
+tab_spaces = 4
diff --git a/tests/config/some_unstable_options.toml b/tests/config/some_unstable_options.toml
@@ -0,0 +1,2 @@
+wrap_comments = true
+unstable_features = true
diff --git a/tests/rustfmt/main.rs b/tests/rustfmt/main.rs

Original file line number	Diff line number	Diff line change
`@@ -144,6 +144,7 @@ fn error_kind_to_snippet_annotation_type(error_kind: &ErrorKind) -> AnnotationTy`
`144`	`144`	`\| ErrorKind::LicenseCheck`
`145`	`145`	`\| ErrorKind::BadAttr`
`146`	`146`	`\| ErrorKind::InvalidGlobPattern(_)`
	`147`	`+ \| ErrorKind::NightlyOnlyOptions(_)`
`147`	`148`	`\| ErrorKind::VersionMismatch => AnnotationType::Error,`
`148`	`149`	`ErrorKind::BadIssue(_) \| ErrorKind::DeprecatedAttr => AnnotationType::Warning,`
`149`	`150`	`}`
Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,3 @@`
	`1`	`+max_width = 100`
	`2`	`+hard_tabs = false`
	`3`	`+tab_spaces = 4`
Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,2 @@`
	`1`	`+wrap_comments = true`
	`2`	`+unstable_features = true`