Store unstable options in a HashMap

To better keep track of all unstable options used they are stored in an
internal HashMap of the Config struct.

Author: ytmimi

src/config/config_type.rs

@@ -65,7 +65,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: Option<Vec<String>>,
+            configured_unstable_options: std::collections::HashMap<String, String>,
             // 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,
@@ -150,49 +150,48 @@ macro_rules! create_config {
             /// Returns None if using nightly or if no unstable options were set.
             /// Otherwise, return all unstable options set by the user.
             #[allow(unreachable_pub)]
-            pub fn unstable_options_set_on_stable_channel(&self) -> Option<&Vec<String>> {
+            pub fn unstable_options_set_on_stable_channel(&self) -> Option<Vec<String>> {
                 if crate::is_nightly_channel!() {
-                    None
+                    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 {
-                    self.configured_unstable_options.as_ref()
+                    None
                 }
             }
 
+            /// Gather all unstable options specified by the user
             #[allow(unreachable_pub)]
             pub fn collect_unstable_options(&mut self) {
                 if crate::is_nightly_channel!() {
                    return
                 }
 
-                let mut unstable_options = vec![];
                 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 {
-                        unstable_options.push(format!("{} = {:?}", stringify!($i), self.$i.2));
+                    if !(self.$i.3) && self.$i.1 && stringify!($i) != abort_option {
+                        self.configured_unstable_options.insert(
+                            stringify!($i).to_owned(), format!("{:?}", self.$i.2)
+                        );
                     }
 
-                )+
-
-                if unstable_options.len() > 0 {
-                    if let Some(mut options) = self.configured_unstable_options.take() {
-                        options.append(&mut unstable_options);
-                        options.sort();
-                        options.dedup();
-                    } else {
-                        self.configured_unstable_options.replace(unstable_options);
-                    }
-                }
+                })+
             }
 
             /// 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_some()
+                !self.configured_unstable_options.is_empty()
             }
 
             /// Return a String warning users about all unstable options used on the stable channel
@@ -243,36 +242,17 @@ macro_rules! create_config {
             }
 
             fn fill_from_parsed_config(mut self, parsed: PartialConfig, dir: &Path) -> Config {
-                let mut unstable_options = vec![];
             $(
                 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 {
-                            // only set abort_on_unrecognised_options, and store all other
-                            // nightly only options
-                            if stringify!($i) != "abort_on_unrecognised_options" {
-                                unstable_options.push(format!("{} = {:?}", stringify!($i), val));
-                            } else {
-                                self.$i.1 = true;
-                                self.$i.2 = val;
-                            }
-                        }
-                    }
+                    self.$i.1 = true;
+                    self.$i.2 = val;
                 }
             )+
-                if unstable_options.len() > 0 {
-                    self.configured_unstable_options = Some(unstable_options);
-                }
                 self.set_heuristics();
                 self.set_license_template();
                 self.set_ignore(dir);
                 self.set_merge_imports();
+                self.collect_unstable_options();
                 self
             }
 
@@ -545,7 +525,7 @@ macro_rules! create_config {
             fn default() -> Config {
                 Config {
                     license_template: None,
-                    configured_unstable_options: None,
+                    configured_unstable_options: std::collections::HashMap::new(),
                     $(
                         $i: (Cell::new(false), false, $def, $stb),
                     )+

src/config/mod.rs

@@ -623,7 +623,7 @@ mod test {
         let config = Config::from_toml(toml, Path::new("")).unwrap();
         assert_eq!(
             config.unstable_options_set_on_stable_channel().unwrap(),
-            &vec!["reorder_impl_items = true"]
+            vec!["reorder_impl_items = true"]
         )
     }