[feat] implement wildcard macro invocation skip

Author: tommilligan

Configurations.md

@@ -1011,33 +1011,47 @@ See also [`format_macro_matchers`](#format_macro_matchers).
 Skip formatting the bodies of macro invocations with the following names.
 
 - **Default value**: `[]`
-- **Possible values**: a list of macro name idents, `["name_0", "name_1", ...]`
+- **Possible values**: a list of macro name idents, `["name_0", "name_1", ..., "*"]`
 - **Stable**: No (tracking issue: [#5346](https://github.com/rust-lang/rustfmt/issues/5346))
 
 #### `[]` (default):
 
-The input:
+All macro invocations will be formatted.
 
 ```rust
-items!(
-        const _: u8 = 0;
+lorem!(
+    const _: u8 = 0;
+);
+
+ipsum!(
+    const _: u8 = 0;
 );
 ```
 
-Is reformatted to:
+#### `["lorem"]`:
+
+The named macro invocations will be skipped.
 
 ```rust
-items!(
+lorem!(
+        const _: u8 = 0;
+);
+
+ipsum!(
     const _: u8 = 0;
 );
 ```
 
-#### `["items"]`:
+#### `["*"]`:
 
-The input is preserved:
+The special selector `*` will skip all macro invocations.
 
 ```rust
-items!(
+lorem!(
+        const _: u8 = 0;
+);
+
+ipsum!(
         const _: u8 = 0;
 );
 ```

src/config/config_type.rs

@@ -1,5 +1,5 @@
 use crate::config::file_lines::FileLines;
-use crate::config::macro_names::MacroNames;
+use crate::config::macro_names::MacroSelectors;
 use crate::config::options::{IgnoreList, WidthHeuristics};
 
 /// Trait for types that can be used in `Config`.
@@ -39,7 +39,7 @@ impl ConfigType for FileLines {
     }
 }
 
-impl ConfigType for MacroNames {
+impl ConfigType for MacroSelectors {
     fn doc_hint() -> String {
         String::from("[<string>, ...]")
     }

src/config/macro_names.rs

@@ -23,35 +23,68 @@ impl From<MacroName> for String {
     }
 }
 
-/// A set of macro names.
-#[derive(Clone, Debug, Default, PartialEq, Deserialize, Serialize)]
-pub struct MacroNames(Vec<MacroName>);
+/// Defines a selector to match against a macro.
+#[derive(Clone, Debug, Eq, PartialEq, Hash, Ord, PartialOrd, Deserialize, Serialize)]
+pub enum MacroSelector {
+    Name(MacroName),
+    All,
+}
 
-impl fmt::Display for MacroNames {
+impl fmt::Display for MacroSelector {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        write!(f, "{}", self.0.iter().format(", "))
+        match self {
+            Self::Name(name) => name.fmt(f),
+            Self::All => write!(f, "*"),
+        }
+    }
+}
+
+impl str::FromStr for MacroSelector {
+    type Err = std::convert::Infallible;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        Ok(match s {
+            "*" => MacroSelector::All,
+            name => MacroSelector::Name(MacroName(name.to_owned())),
+        })
     }
 }
 
-impl MacroNames {
-    /// Return the underlying macro names, as an iterator of strings.
-    pub(crate) fn into_name_strings(self) -> impl Iterator<Item = String> {
-        self.0.into_iter().map(Into::into)
+/// A set of macro selectors.
+#[derive(Clone, Debug, Default, PartialEq, Deserialize, Serialize)]
+pub struct MacroSelectors(Vec<MacroSelector>);
+
+impl MacroSelectors {
+    pub fn into_inner(self) -> Vec<MacroSelector> {
+        self.0
+    }
+}
+
+impl fmt::Display for MacroSelectors {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.0.iter().format(", "))
     }
 }
 
 #[derive(Error, Debug)]
-pub enum MacroNamesError {
+pub enum MacroSelectorsError {
     #[error("{0}")]
     Json(json::Error),
 }
 
 // This impl is needed for `Config::override_value` to work for use in tests.
-impl str::FromStr for MacroNames {
-    type Err = MacroNamesError;
+impl str::FromStr for MacroSelectors {
+    type Err = MacroSelectorsError;
 
-    fn from_str(s: &str) -> Result<MacroNames, Self::Err> {
-        json::from_str(s).map_err(MacroNamesError::Json)
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        let raw: Vec<&str> = json::from_str(s).map_err(MacroSelectorsError::Json)?;
+        Ok(Self(
+            raw.into_iter()
+                .map(|raw| {
+                    MacroSelector::from_str(raw).expect("MacroSelector from_str is infallible")
+                })
+                .collect(),
+        ))
     }
 }
 
@@ -62,20 +95,24 @@ mod test {
 
     #[test]
     fn macro_names_from_str() {
-        let macro_names = MacroNames::from_str(r#"["foo", "bar"]"#).unwrap();
+        let macro_names = MacroSelectors::from_str(r#"["foo", "*", "bar"]"#).unwrap();
         assert_eq!(
             macro_names,
-            MacroNames(
-                [MacroName("foo".to_owned()), MacroName("bar".to_owned())]
-                    .into_iter()
-                    .collect()
+            MacroSelectors(
+                [
+                    MacroSelector::Name(MacroName("foo".to_owned())),
+                    MacroSelector::All,
+                    MacroSelector::Name(MacroName("bar".to_owned()))
+                ]
+                .into_iter()
+                .collect()
             )
         );
     }
 
     #[test]
     fn macro_names_display() {
-        let macro_names = MacroNames::from_str(r#"["foo", "bar"]"#).unwrap();
-        assert_eq!(format!("{}", macro_names), "foo, bar");
+        let macro_names = MacroSelectors::from_str(r#"["foo", "*", "bar"]"#).unwrap();
+        assert_eq!(format!("{}", macro_names), "foo, *, bar");
     }
 }

src/config/mod.rs

@@ -14,7 +14,7 @@ pub use crate::config::file_lines::{FileLines, FileName, Range};
 #[allow(unreachable_pub)]
 pub use crate::config::lists::*;
 #[allow(unreachable_pub)]
-pub use crate::config::macro_names::MacroNames;
+pub use crate::config::macro_names::{MacroSelector, MacroSelectors};
 #[allow(unreachable_pub)]
 pub use crate::config::options::*;
 
@@ -72,7 +72,7 @@ create_config! {
     format_macro_matchers: bool, false, false,
         "Format the metavariable matching patterns in macros";
     format_macro_bodies: bool, true, false, "Format the bodies of macros";
-    skip_macro_names: MacroNames, MacroNames::default(), false,
+    skip_macro_names: MacroSelectors, MacroSelectors::default(), false,
         "Skip formatting the bodies of macros invoked with the following names.";
     hex_literal_case: HexLiteralCase, HexLiteralCase::Preserve, false,
         "Format hexadecimal integer literals";

src/skip.rs

@@ -7,6 +7,7 @@ use rustc_ast_pretty::pprust;
 /// by other context. Query this context to know if you need skip a block.
 #[derive(Default, Clone)]
 pub(crate) struct SkipContext {
+    pub(crate) all_macros: bool,
     macros: Vec<String>,
     attributes: Vec<String>,
 }
@@ -31,7 +32,7 @@ impl SkipContext {
     }
 
     pub(crate) fn skip_macro(&self, name: &str) -> bool {
-        self.macros.iter().any(|n| n == name)
+        self.all_macros || self.macros.iter().any(|n| n == name)
     }
 
     pub(crate) fn skip_attribute(&self, name: &str) -> bool {

src/test/configuration_snippet.rs

@@ -27,8 +27,13 @@ impl ConfigurationSection {
         lazy_static! {
             static ref CONFIG_NAME_REGEX: regex::Regex =
                 regex::Regex::new(r"^## `([^`]+)`").expect("failed creating configuration pattern");
+            // Configuration values, which will be passed to `from_str`:
+            //
+            // - must be prefixed with `####`
+            // - must be wrapped in backticks
+            // - may by wrapped in double quotes (which will be stripped)
             static ref CONFIG_VALUE_REGEX: regex::Regex =
-                regex::Regex::new(r#"^#### `"?([^`"]+)"?`"#)
+                regex::Regex::new(r#"^#### `"?([^`]+?)"?`"#)
                     .expect("failed creating configuration value pattern");
         }
 

src/visitor.rs

@@ -8,7 +8,7 @@ use rustc_span::{symbol, BytePos, Pos, Span};
 use crate::attr::*;
 use crate::comment::{contains_comment, rewrite_comment, CodeCharKind, CommentCodeSlices};
 use crate::config::Version;
-use crate::config::{BraceStyle, Config};
+use crate::config::{BraceStyle, Config, MacroSelector};
 use crate::coverage::transform_missing_snippet;
 use crate::items::{
     format_impl, format_trait, format_trait_alias, is_mod_decl, is_use_item, rewrite_extern_crate,
@@ -770,7 +770,14 @@ impl<'b, 'a: 'b> FmtVisitor<'a> {
         memoize: Memoize,
     ) -> FmtVisitor<'a> {
         let mut skip_context = SkipContext::default();
-        skip_context.update_macros(config.skip_macro_names().into_name_strings());
+        let mut macro_names = Vec::new();
+        for macro_selector in config.skip_macro_names().into_inner() {
+            match macro_selector {
+                MacroSelector::Name(name) => macro_names.push(name.to_string()),
+                MacroSelector::All => skip_context.all_macros = true,
+            }
+        }
+        skip_context.update_macros(macro_names);
         FmtVisitor {
             parent_context: None,
             parse_sess: parse_session,