Move WrapComments into own module, include aliases in all errors

Author: Nemo157

src/config/config_type.rs

@@ -1,6 +1,7 @@
 use crate::config::file_lines::FileLines;
 use crate::config::macro_names::MacroSelectors;
 use crate::config::options::{IgnoreList, WidthHeuristics};
+use crate::config::WrapComments;
 
 /// Trait for types that can be used in `Config`.
 pub(crate) trait ConfigType: Sized {
@@ -65,6 +66,12 @@ impl ConfigType for IgnoreList {
     }
 }
 
+impl ConfigType for WrapComments {
+    fn doc_hint() -> String {
+        "[ Off (false) | All (true) | Doc | Normal ]".to_owned()
+    }
+}
+
 macro_rules! create_config {
     // Options passed into the macro.
     //

src/config/mod.rs

@@ -15,6 +15,7 @@ pub use crate::config::lists::*;
 pub use crate::config::macro_names::{MacroSelector, MacroSelectors};
 #[allow(unreachable_pub)]
 pub use crate::config::options::*;
+pub(crate) use crate::config::wrap_comments::WrapComments;
 
 #[macro_use]
 pub(crate) mod config_type;
@@ -27,6 +28,7 @@ pub(crate) mod file_lines;
 pub(crate) mod lists;
 pub(crate) mod macro_names;
 pub(crate) mod style_edition;
+mod wrap_comments;
 
 // This macro defines configuration options used in rustfmt. Each option
 // is defined as follows:

src/config/options.rs

@@ -216,97 +216,6 @@ pub enum Verbosity {
     Quiet,
 }
 
-/// Which comments to wrap
-#[derive(Copy, Clone, Debug, Eq, PartialEq, Serialize)]
-pub enum WrapComments {
-    /// Don't wrap comments
-    Off,
-    /// Wrap all kinds of comments
-    All,
-    /// Only wrap doc comments
-    Doc,
-    /// Only wrap normal comments
-    Normal,
-}
-
-impl WrapComments {
-    pub(crate) fn is_normal(self) -> bool {
-        matches!(self, WrapComments::All | WrapComments::Normal)
-    }
-
-    pub(crate) fn is_doc(self) -> bool {
-        matches!(self, WrapComments::All | WrapComments::Doc)
-    }
-}
-
-impl fmt::Display for WrapComments {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            WrapComments::Off => f.write_str("Off"),
-            WrapComments::All => f.write_str("All"),
-            WrapComments::Doc => f.write_str("Doc"),
-            WrapComments::Normal => f.write_str("Normal"),
-        }
-    }
-}
-
-impl super::ConfigType for WrapComments {
-    fn doc_hint() -> String {
-        "[Off|All|Doc|Normal]".to_owned()
-    }
-
-    fn stable_variant(&self) -> bool {
-        true
-    }
-}
-
-impl std::str::FromStr for WrapComments {
-    type Err = &'static str;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        match s.to_lowercase().as_str() {
-            "off" | "false" => Ok(WrapComments::Off),
-            "all" | "true" => Ok(WrapComments::All),
-            "doc" => Ok(WrapComments::Doc),
-            "normal" => Ok(WrapComments::Normal),
-            _ => Err("Bad variant, expected one of: `Off` `All` `Doc` `Normal`"),
-        }
-    }
-}
-
-impl<'de> serde::de::Deserialize<'de> for WrapComments {
-    fn deserialize<D>(d: D) -> Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        use serde::de::Error;
-
-        struct StringOrBoolVisitor;
-
-        impl<'de> Visitor<'de> for StringOrBoolVisitor {
-            type Value = String;
-
-            fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
-                formatter.write_str("string")
-            }
-
-            fn visit_str<E>(self, value: &str) -> Result<String, E> {
-                Ok(String::from(value))
-            }
-
-            fn visit_bool<E>(self, value: bool) -> Result<String, E> {
-                Ok(value.to_string())
-            }
-        }
-
-        let s = d.deserialize_string(StringOrBoolVisitor)?;
-        s.parse().map_err(|_| {
-            static ALLOWED: &'static [&str] = &["Off", "All", "Doc", "Normal"];
-            D::Error::unknown_variant(&s, ALLOWED)
-        })
-    }
-}
-
 #[derive(Deserialize, Serialize, Clone, Debug, PartialEq)]
 pub struct WidthHeuristics {
     // Maximum width of the args of a function call before falling back

src/config/wrap_comments.rs

@@ -0,0 +1,84 @@
+use std::fmt;
+
+/// Which comments to wrap
+#[derive(Copy, Clone, Debug, Eq, PartialEq, serde::Serialize)]
+pub enum WrapComments {
+    /// Don't wrap comments
+    Off,
+    /// Wrap all kinds of comments
+    All,
+    /// Only wrap doc comments
+    Doc,
+    /// Only wrap normal comments
+    Normal,
+}
+
+impl WrapComments {
+    pub(crate) fn is_normal(self) -> bool {
+        matches!(self, WrapComments::All | WrapComments::Normal)
+    }
+
+    pub(crate) fn is_doc(self) -> bool {
+        matches!(self, WrapComments::All | WrapComments::Doc)
+    }
+}
+
+impl fmt::Display for WrapComments {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            WrapComments::Off => f.write_str("Off"),
+            WrapComments::All => f.write_str("All"),
+            WrapComments::Doc => f.write_str("Doc"),
+            WrapComments::Normal => f.write_str("Normal"),
+        }
+    }
+}
+
+impl std::str::FromStr for WrapComments {
+    type Err = &'static str;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        match s.to_lowercase().as_str() {
+            "off" | "false" => Ok(WrapComments::Off),
+            "all" | "true" => Ok(WrapComments::All),
+            "doc" => Ok(WrapComments::Doc),
+            "normal" => Ok(WrapComments::Normal),
+            _ => {
+                Err("Bad variant, expected one of: `Off`, `false`, `All`, `true`, `Doc`, `Normal`")
+            }
+        }
+    }
+}
+
+impl<'de> serde::de::Deserialize<'de> for WrapComments {
+    fn deserialize<D>(d: D) -> Result<Self, D::Error>
+    where
+        D: serde::Deserializer<'de>,
+    {
+        use serde::de::Error;
+
+        struct StringOrBoolVisitor;
+
+        impl<'de> serde::de::Visitor<'de> for StringOrBoolVisitor {
+            type Value = String;
+
+            fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+                formatter.write_str("string")
+            }
+
+            fn visit_str<E>(self, value: &str) -> Result<String, E> {
+                Ok(String::from(value))
+            }
+
+            fn visit_bool<E>(self, value: bool) -> Result<String, E> {
+                Ok(value.to_string())
+            }
+        }
+
+        let s = d.deserialize_string(StringOrBoolVisitor)?;
+        s.parse().map_err(|_| {
+            static ALLOWED: &'static [&str] = &["Off", "false", "All", "true", "Doc", "Normal"];
+            D::Error::unknown_variant(&s, ALLOWED)
+        })
+    }
+}