Implement custom error type for load_config

Author: ytmimi

src/bin/main.rs

@@ -276,7 +276,6 @@ fn format_string(input: String, options: GetOptsOptions) -> Result<i32> {
     }
 
     let out = &mut stdout();
-    rustfmt::abort_or_warn_on_unstable_options!(config);
     let mut session = Session::new(config, Some(out));
     format_and_emit_report(&mut session, Input::Text(input));
 
@@ -304,7 +303,6 @@ fn format(
 
     let out = &mut stdout();
 
-    rustfmt::abort_or_warn_on_unstable_options!(config);
     let mut session = Session::new(config, Some(out));
 
     for file in files {
@@ -329,7 +327,6 @@ fn format(
                     }
                 }
 
-                rustfmt::abort_or_warn_on_unstable_options!(local_config);
                 session.override_config(local_config, |sess| {
                     format_and_emit_report(sess, Input::File(file))
                 });

src/config/config_type.rs

@@ -158,6 +158,37 @@ macro_rules! create_config {
                 }
             }
 
+            #[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 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 {

src/config/mod.rs

@@ -325,29 +325,62 @@ impl Config {
 
     /// When using nightly options on stable channel decide whether to abort or
     /// log out warnings to the user.
-    pub fn abort_or_warn_on_unstable_options(&self) -> Option<HandleUnstableOptions> {
+    pub fn abort_or_warn_on_unstable_options(&self) -> HandleUnstableOptions {
         if !self.using_unstable_options_on_stable_channel() {
-            return None;
+            return HandleUnstableOptions::Continue;
         }
 
         if self.abort_on_unrecognised_options() {
-            Some(HandleUnstableOptions::Abort(
-                self.unstable_options_abort_message().unwrap(),
-            ))
+            HandleUnstableOptions::Abort(self.unstable_options_abort_message().unwrap())
         } else {
-            Some(HandleUnstableOptions::Warn(
-                self.unstable_options_warning_message().unwrap(),
-            ))
+            HandleUnstableOptions::Warn(self.unstable_options_warning_message().unwrap())
         }
     }
 }
 
+/// Errors that can occur when loading configuration
+#[derive(Debug)]
+pub enum LoadConfigurationError {
+    /// An io error when reading configuration.
+    IoError(std::io::Error),
+    /// Used unstable options on the stable channel
+    UsedUnstableOptions(String),
+}
+
+impl From<std::io::Error> for LoadConfigurationError {
+    fn from(e: std::io::Error) -> LoadConfigurationError {
+        LoadConfigurationError::IoError(e)
+    }
+}
+
+impl std::error::Error for LoadConfigurationError {}
+
+impl std::fmt::Display for LoadConfigurationError {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            Self::IoError(e) => e.fmt(f),
+            Self::UsedUnstableOptions(msg) => {
+                write!(f, "{}", msg)
+            }
+        }
+    }
+}
+
+pub enum HandleUnstableOptions {
+    // Exit early. Do not allow rustfmt to format any files
+    Abort(String),
+    // Warn the user that they are using unstable options and format files
+    Warn(String),
+    // Proceed as normal. No need to warn or abort.
+    Continue,
+}
+
 /// Loads a config by checking the client-supplied options and if appropriate, the
 /// file system (including searching the file system for overrides).
 pub fn load_config<O: CliOptions>(
     file_path: Option<&Path>,
     options: Option<O>,
-) -> Result<(Config, Option<PathBuf>), Error> {
+) -> Result<(Config, Option<PathBuf>), LoadConfigurationError> {
     let over_ride = match options {
         Some(ref opts) => config_path(opts)?,
         None => None,
@@ -361,12 +394,23 @@ pub fn load_config<O: CliOptions>(
         Ok((Config::default(), None))
     };
 
-    result.map(|(mut c, p)| {
+    let (config, options) = result.map(|(mut c, p)| {
         if let Some(options) = options {
             options.apply_to(&mut c);
+            c.collect_unstable_options();
         }
         (c, p)
-    })
+    })?;
+
+    use HandleUnstableOptions::{Abort, Continue, Warn};
+    match config.abort_or_warn_on_unstable_options() {
+        Abort(s) => Err(LoadConfigurationError::UsedUnstableOptions(s)),
+        Warn(warning) => {
+            eprint!("{}", warning);
+            Ok((config, options))
+        }
+        Continue => Ok((config, options)),
+    }
 }
 
 // Check for the presence of known config file names (`rustfmt.toml, `.rustfmt.toml`) in `dir`
@@ -420,29 +464,6 @@ fn config_path(options: &dyn CliOptions) -> Result<Option<PathBuf>, Error> {
     }
 }
 
-#[macro_export]
-macro_rules! abort_or_warn_on_unstable_options {
-    ($config:expr) => {
-        match $config.abort_or_warn_on_unstable_options() {
-            Some($crate::HandleUnstableOptions::Abort(message)) => {
-                eprint!("{}", message);
-                return Ok(1);
-            }
-            Some($crate::HandleUnstableOptions::Warn(message)) => {
-                eprint!("{}", message);
-            }
-            None => {}
-        }
-    };
-}
-
-#[allow(unreachable_pub)]
-pub use abort_or_warn_on_unstable_options;
-pub enum HandleUnstableOptions {
-    Abort(String),
-    Warn(String),
-}
-
 #[cfg(test)]
 mod test {
     use super::*;
@@ -701,7 +722,7 @@ Set `abort_on_unrecognised_options = false` to convert this error into a warning
         let config = Config::from_toml(toml, Path::new("")).unwrap();
         assert!(matches!(
             config.abort_or_warn_on_unstable_options(),
-            Some(HandleUnstableOptions::Warn(_))
+            HandleUnstableOptions::Warn(_)
         ))
     }
 
@@ -718,7 +739,7 @@ Set `abort_on_unrecognised_options = false` to convert this error into a warning
         let config = Config::from_toml(toml, Path::new("")).unwrap();
         assert!(matches!(
             config.abort_or_warn_on_unstable_options(),
-            Some(HandleUnstableOptions::Abort(_))
+            HandleUnstableOptions::Abort(_)
         ))
     }
 
@@ -733,7 +754,10 @@ Set `abort_on_unrecognised_options = false` to convert this error into a warning
             array_width = 50
         "#;
         let config = Config::from_toml(toml, Path::new("")).unwrap();
-        assert!(matches!(config.abort_or_warn_on_unstable_options(), None))
+        assert!(matches!(
+            config.abort_or_warn_on_unstable_options(),
+            HandleUnstableOptions::Continue
+        ))
     }
 
     #[test]
@@ -747,7 +771,10 @@ Set `abort_on_unrecognised_options = false` to convert this error into a warning
             array_width = 50
         "#;
         let config = Config::from_toml(toml, Path::new("")).unwrap();
-        assert!(matches!(config.abort_or_warn_on_unstable_options(), None))
+        assert!(matches!(
+            config.abort_or_warn_on_unstable_options(),
+            HandleUnstableOptions::Continue
+        ))
     }
 
     #[test]

src/lib.rs

@@ -45,8 +45,8 @@ use crate::syntux::parser::DirectoryOwnership;
 use crate::utils::indent_next_line;
 
 pub use crate::config::{
-    load_config, CliOptions, Color, Config, Edition, EmitMode, FileLines, FileName,
-    HandleUnstableOptions, NewlineStyle, Range, Verbosity,
+    load_config, CliOptions, Color, Config, Edition, EmitMode, FileLines, FileName, NewlineStyle,
+    Range, Verbosity,
 };
 
 pub use crate::format_report_formatter::{FormatReportFormatter, FormatReportFormatterBuilder};