Add UnstableOptions struct to Config

The UnstableOptions struct internally contains the map used to store
user specified unstable options. All unstable options Are stored in this
struct and when a LoadConfigurationError::AbortOnUnstableOptions error
occurs in ``load_config``, the UnstableOptions struct is returned to the
caller to give more context as to which ustable options were set.

Author: ytmimi

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)]
@@ -65,7 +139,7 @@ macro_rules! create_config {
             // into a regex, it will be stored here
             pub license_template: Option<Regex>,
             // Unstable Options specified on the stable channel
-            configured_unstable_options: std::collections::HashMap<String, String>,
+            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,
@@ -147,103 +221,33 @@ macro_rules! create_config {
                 ConfigWasSet(self)
             }
 
-            /// Returns None if using nightly or if no unstable options were set.
-            /// Otherwise, return all unstable options set by the user.
+            /// 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 unstable_options_set_on_stable_channel(&self) -> Option<Vec<String>> {
-                if crate::is_nightly_channel!() {
-                    return None;
-                }
-
-                if self.using_unstable_options_on_stable_channel() {
-                    Some(self.configured_unstable_options.iter()
-                        .map(|(k, v)| format!("{} = {}", k, v))
-                        .collect::<Vec<_>>()
-                    )
-                } else {
-                    None
-                }
-            }
-
-            /// Gather all unstable options specified by the user
-            #[allow(unreachable_pub)]
-            pub fn collect_unstable_options(&mut self) {
-                if crate::is_nightly_channel!() {
+            pub fn insert_unstable_options(&mut self, option: &'static str, value: String) {
+                if option == "abort_on_unrecognised_options" {
                    return
                 }
 
-                let abort_option = "abort_on_unrecognised_options";
-
-                $({
-                    // self.$i.3 = 'is this a stable options'
-                    // self.$1.1 = 'was this set by the user'
-                    // the abort option is currently unstable so it needs to be special cased
-                    // otherwise we would abort when using it.
-                    if !(self.$i.3) && self.$i.1 && stringify!($i) != abort_option {
-                        self.configured_unstable_options.insert(
-                            stringify!($i).to_owned(), format!("{:?}", self.$i.2)
-                        );
+                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);
+                        }
                     }
-
-                })+
-            }
-
-            /// Returns true if any unstable options were set while on the stable channel
-            #[allow(unreachable_pub)]
-            pub fn using_unstable_options_on_stable_channel(&self) -> bool {
-                !self.configured_unstable_options.is_empty()
-            }
-
-            /// Return a String warning users about all unstable options used on the stable channel
-            #[allow(unreachable_pub)]
-            pub fn unstable_options_warning_message(&self) -> Option<String> {
-                let unstable_options = self.unstable_options_set_on_stable_channel()?;
-                let upgrade_to_abort_message = "\nSet `abort_on_unrecognised_options = true` \
-                to convert this warning into an error\n\n";
-                // Capacity of 120 * len should be enough space for all options.
-                // the Warning string below is ~80 characters long so there is
-                // ~40 char buffer for option name and value
-                let mut output = String::with_capacity(
-                    upgrade_to_abort_message.len() + unstable_options.len() * 120
-                );
-
-                for option in unstable_options {
-                    output.push_str(
-                        &format!("Warning: can't set `{}`, unstable features are only \
-                            available in nightly channel.\n", option
-                        )
-                    );
+                )+
+                    _ => panic!("Unknown config key in override: {}", option)
                 }
 
-                output.push_str(upgrade_to_abort_message);
-
-                Some(output)
-            }
-
-            /// Returns a String explaining why rustfmt exited early when using unstable options
-            /// on the stable channel
-            #[allow(unreachable_pub)]
-            pub fn unstable_options_abort_message(&self) -> Option<String> {
-                let unstable_options = self.unstable_options_set_on_stable_channel()?;
-                let first_line = "Can't set nightly options when using stable rustfmt\n";
-                let to_warning_message = "\nSet `abort_on_unrecognised_options = false` \
-                to convert this error into a warning\n\n";
-                // 40 = buffer we'll use for all options. Most will be less than 40 char long
-                let mut output = String::with_capacity(
-                    to_warning_message.len() + first_line.len() + unstable_options.len() * 40
-                );
-                output.push_str(first_line);
-
-                for option in unstable_options {
-                    output.push_str(&format!("    - `{}`\n", option));
-                }
-                output.push_str(to_warning_message);
-                Some(output)
             }
 
             fn fill_from_parsed_config(mut self, parsed: PartialConfig, dir: &Path) -> Config {
             $(
                 if let Some(val) = parsed.$i {
+                    self.insert_unstable_options(stringify!($i), format!("{:?}", &val));
                     self.$i.1 = true;
                     self.$i.2 = val;
                 }
@@ -252,7 +256,6 @@ macro_rules! create_config {
                 self.set_license_template();
                 self.set_ignore(dir);
                 self.set_merge_imports();
-                self.collect_unstable_options();
                 self
             }
 
@@ -307,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)
             {
@@ -319,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)
@@ -525,7 +535,7 @@ macro_rules! create_config {
             fn default() -> Config {
                 Config {
                     license_template: None,
-                    configured_unstable_options: std::collections::HashMap::new(),
+                    configured_unstable_options: UnstableOptions::new(),
                     $(
                         $i: (Cell::new(false), false, $def, $stb),
                     )+