[review] allow setting unstable variants with --config

Author: tommilligan

src/config/config_type.rs

@@ -239,13 +239,17 @@ macro_rules! create_config {
                                                  stringify!($i),
                                                  val,
                                                  stringify!($ty)));
-                            let option_stable = self.$i.3;
-                            if $crate::config::config_type::is_stable_option_and_value(
-                                stringify!($i), option_stable, &option_value
-                            ) {
-                                self.$i.1 = true;
-                                self.$i.2 = option_value;
-                            }
+
+                            // Users are currently allowed to set unstable
+                            // options/variants via the `--config` options override.
+                            //
+                            // There is ongoing discussion about how to move forward here:
+                            // https://github.com/rust-lang/rustfmt/pull/5379
+                            //
+                            // For now, do not validate whether the option or value is stable,
+                            // just always set it.
+                            self.$i.1 = true;
+                            self.$i.2 = option_value;
                         }
                     )+
                     _ => panic!("Unknown config key in override: {}", key)

src/config/mod.rs

@@ -461,6 +461,61 @@ mod test {
             partially_unstable_option: PartiallyUnstableOption, PartiallyUnstableOption::V1, true,
                 "A partially unstable option";
         }
+
+        #[cfg(test)]
+        mod partially_unstable_option {
+            use super::{Config, PartialConfig, PartiallyUnstableOption};
+            use rustfmt_config_proc_macro::{nightly_only_test, stable_only_test};
+            use std::path::Path;
+
+            /// From the config file, we can fill with a stable variant
+            #[test]
+            fn test_from_toml_stable_value() {
+                let toml = r#"
+                    partially_unstable_option = "V2"
+                "#;
+                let partial_config: PartialConfig = toml::from_str(toml).unwrap();
+                let config = Config::default();
+                let config = config.fill_from_parsed_config(partial_config, Path::new(""));
+                assert_eq!(
+                    config.partially_unstable_option(),
+                    PartiallyUnstableOption::V2
+                );
+            }
+
+            /// From the config file, we cannot fill with an unstable variant (stable only)
+            #[stable_only_test]
+            #[test]
+            fn test_from_toml_unstable_value_on_stable() {
+                let toml = r#"
+                    partially_unstable_option = "V3"
+                "#;
+                let partial_config: PartialConfig = toml::from_str(toml).unwrap();
+                let config = Config::default();
+                let config = config.fill_from_parsed_config(partial_config, Path::new(""));
+                assert_eq!(
+                    config.partially_unstable_option(),
+                    // default value from config, i.e. fill failed
+                    PartiallyUnstableOption::V1
+                );
+            }
+
+            /// From the config file, we can fill with an unstable variant (nightly only)
+            #[nightly_only_test]
+            #[test]
+            fn test_from_toml_unstable_value_on_nightly() {
+                let toml = r#"
+                    partially_unstable_option = "V3"
+                "#;
+                let partial_config: PartialConfig = toml::from_str(toml).unwrap();
+                let config = Config::default();
+                let config = config.fill_from_parsed_config(partial_config, Path::new(""));
+                assert_eq!(
+                    config.partially_unstable_option(),
+                    PartiallyUnstableOption::V3
+                );
+            }
+        }
     }
 
     #[test]
@@ -939,6 +994,7 @@ make_backup = false
         use super::mock::{Config, PartiallyUnstableOption};
         use super::*;
 
+        /// From the command line, we can override with a stable variant.
         #[test]
         fn test_override_stable_value() {
             let mut config = Config::default();
@@ -949,20 +1005,9 @@ make_backup = false
             );
         }
 
-        #[stable_only_test]
-        #[test]
-        fn test_override_unstable_value_on_stable() {
-            let mut config = Config::default();
-            config.override_value("partially_unstable_option", "V3");
-            assert_eq!(
-                config.partially_unstable_option(),
-                PartiallyUnstableOption::V1
-            );
-        }
-
-        #[nightly_only_test]
+        /// From the command line, we can override with an unstable variant.
         #[test]
-        fn test_override_unstable_value_on_nightly() {
+        fn test_override_unstable_value() {
             let mut config = Config::default();
             config.override_value("partially_unstable_option", "V3");
             assert_eq!(