feat: support wildcards for group_imports

Author: l4l

CHANGELOG.md

@@ -68,6 +68,7 @@
 ### Added
 
 - Users can now set `skip_macro_invocations` in `rustfmt.toml` [#5816](https://github.com/rust-lang/rustfmt/issues/5816)
+- Supported custom wildcarded groups for [group_imports](https://rust-lang.github.io/rustfmt/?version=v1.4.38&search=#group_imports).
 
 ### Misc
 

Configurations.md

@@ -2229,7 +2229,7 @@ Controls the strategy for how consecutive imports are grouped together.
 Controls the strategy for grouping sets of consecutive imports. Imports may contain newlines between imports and still be grouped together as a single set, but other statements between imports will result in different grouping sets.
 
 - **Default value**: `Preserve`
-- **Possible values**: `Preserve`, `StdExternalCrate`, `One`
+- **Possible values**: `Preserve`, `StdExternalCrate`, `One`, custom wildcard groups
 - **Stable**: No (tracking issue: [#5083](https://github.com/rust-lang/rustfmt/issues/5083))
 
 Each set of imports (one or more `use` statements, optionally separated by newlines) will be formatted independently. Other statements such as `mod ...` or `extern crate ...` will cause imports to not be grouped together.
@@ -2294,6 +2294,39 @@ use std::sync::Arc;
 use uuid::Uuid;
 ```
 
+#### Example for custom groups:
+
+Discard existing import groups, and create groups as specified by the wildcarded list.
+Handy aliases are supported:
+
+- `$std` prefix is an alias for standard library (i.e `std`, `core`, `alloc`);
+- `$crate` prefix is an alias for crate-local modules (i.e `self`, `crate`, `super`).
+
+For a given config:
+
+```toml
+group_imports = [
+    ["$std::*", "proc_macro::*"],
+    ["my_crate::*", "crate::*::xyz"],
+    ["$crate::*"],
+]
+```
+
+The following order would be set:
+
+```rust
+use proc_macro::Span;
+use std::rc::Rc;
+
+use crate::abc::xyz;
+use my_crate::a::B;
+use my_crate::A;
+
+use self::X;
+use super::Y;
+use crate::Z;
+```
+
 ## `reorder_modules`
 
 Reorder `mod` declarations alphabetically in group.

src/config/options.rs

@@ -1,5 +1,7 @@
 use std::collections::{hash_set, HashSet};
+use std::convert::TryFrom;
 use std::fmt;
+use std::ops::Deref;
 use std::path::{Path, PathBuf};
 use std::str::FromStr;
 
@@ -102,7 +104,7 @@ impl Density {
     }
 }
 
-#[config_type]
+#[config_type(skip_derive(Copy, Serialize, Deserialize))]
 /// Configuration for import groups, i.e. sets of imports separated by newlines.
 pub enum GroupImportsTactic {
     /// Keep groups as they are.
@@ -114,6 +116,167 @@ pub enum GroupImportsTactic {
     StdExternalCrate,
     /// Discard existing groups, and create a single group for everything
     One,
+    /// Discard existing groups, and create groups as specified by the wildcarded list.
+    /// Handy aliases are supported:
+    ///
+    /// - `$std` prefix is an alias for standard library (i.e `std`, `core`, `alloc`);
+    /// - `$crate` prefix is an alias for crate-local modules (i.e `self`, `crate`, `super`).
+    Wildcards(super::WildcardGroups),
+}
+
+impl Serialize for GroupImportsTactic {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        #[derive(Serialize)]
+        enum Simple {
+            Preserve,
+            StdExternalCrate,
+            One,
+        }
+
+        #[derive(Serialize)]
+        struct WildcardHelper(Vec<Vec<String>>);
+
+        match self {
+            GroupImportsTactic::Preserve => Simple::Preserve.serialize(serializer),
+            GroupImportsTactic::StdExternalCrate => Simple::StdExternalCrate.serialize(serializer),
+            GroupImportsTactic::One => Simple::One.serialize(serializer),
+            GroupImportsTactic::Wildcards(w) => WildcardHelper(
+                w.iter()
+                    .map(|w| w.0.iter().map(|l| l.as_str().to_string()).collect())
+                    .collect(),
+            )
+            .serialize(serializer),
+        }
+    }
+}
+
+impl<'de> Deserialize<'de> for GroupImportsTactic {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        struct Vis;
+        impl<'v> Visitor<'v> for Vis {
+            type Value = GroupImportsTactic;
+
+            fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
+                formatter.write_str("String or sequence")
+            }
+
+            fn visit_str<E: serde::de::Error>(self, s: &str) -> Result<Self::Value, E> {
+                static ALLOWED: &[&'static str] = &["Preserve", "StdExternalCrate", "One"];
+                match s {
+                    "Preserve" => Ok(GroupImportsTactic::Preserve),
+                    "StdExternalCrate" => Ok(GroupImportsTactic::StdExternalCrate),
+                    "One" => Ok(GroupImportsTactic::One),
+                    _ => Err(E::unknown_variant(s, ALLOWED)),
+                }
+            }
+
+            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
+            where
+                A: SeqAccess<'v>,
+            {
+                let mut lines = Vec::<Vec<String>>::new();
+                while let Some(elem) = seq.next_element()? {
+                    lines.push(elem);
+                }
+
+                lines
+                    .into_iter()
+                    .map(TryFrom::try_from)
+                    .collect::<Result<Vec<_>, _>>()
+                    .map(WildcardGroups)
+                    .map(GroupImportsTactic::Wildcards)
+                    .map_err(serde::de::Error::custom)
+            }
+        }
+
+        let imports: Self = deserializer.deserialize_any(Vis)?;
+        Ok(imports)
+    }
+}
+
+#[derive(Debug, Clone, Eq, PartialEq)]
+pub struct WildcardGroups(Vec<WildcardGroup>);
+
+impl Deref for WildcardGroups {
+    type Target = [WildcardGroup];
+
+    fn deref(&self) -> &Self::Target {
+        self.0.as_slice()
+    }
+}
+
+impl fmt::Display for WildcardGroups {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        f.write_str("[")?;
+        for w in &self.0 {
+            write!(f, "{:?}", w)?;
+        }
+        f.write_str("]")
+    }
+}
+
+#[derive(Debug, Clone)]
+pub struct WildcardGroup(Vec<regex::Regex>);
+
+impl WildcardGroup {
+    pub(crate) fn matches(&self, path: &str) -> bool {
+        self.0.iter().any(|w| w.is_match(path))
+    }
+}
+
+impl TryFrom<Vec<String>> for WildcardGroup {
+    type Error = regex::Error;
+
+    fn try_from(i: Vec<String>) -> Result<Self, Self::Error> {
+        enum Kind {
+            Std,
+            Crate,
+        }
+
+        i.into_iter()
+            .map(|s| {
+                let (s, kind) = if let Some(tail) = s.strip_prefix("$std") {
+                    (tail, Some(Kind::Std))
+                } else if let Some(tail) = s.strip_prefix("$crate") {
+                    (tail, Some(Kind::Crate))
+                } else {
+                    (s.as_str(), None)
+                };
+
+                // poor man's wildcard
+                let mut wildcard = regex::escape(s).replace("\\*", ".*");
+                match kind {
+                    None => {}
+                    Some(Kind::Std) => wildcard.insert_str(0, "(::)?(std|core|alloc)"),
+                    Some(Kind::Crate) => wildcard.insert_str(0, "(::)?(self|crate|super)"),
+                }
+
+                regex::Regex::new(&format!("^{wildcard}$"))
+            })
+            .collect::<Result<_, _>>()
+            .map(Self)
+    }
+}
+
+impl Eq for WildcardGroup {}
+
+impl std::cmp::PartialEq for WildcardGroup {
+    fn eq(&self, other: &Self) -> bool {
+        if self.0.len() != other.0.len() {
+            return false;
+        }
+
+        self.0
+            .iter()
+            .zip(other.0.iter())
+            .all(|(a, b)| a.as_str() == b.as_str())
+    }
 }
 
 #[config_type]

src/reorder.rs

@@ -11,7 +11,7 @@ use std::cmp::{Ord, Ordering};
 use rustc_ast::{ast, attr};
 use rustc_span::{symbol::sym, Span};
 
-use crate::config::{Config, GroupImportsTactic};
+use crate::config::{Config, GroupImportsTactic, WildcardGroups};
 use crate::imports::{normalize_use_trees_with_granularity, UseSegmentKind, UseTree};
 use crate::items::{is_mod_decl, rewrite_extern_crate, rewrite_mod};
 use crate::lists::{itemize_list, write_list, ListFormatting, ListItem};
@@ -117,6 +117,7 @@ fn rewrite_reorderable_or_regroupable_items(
                     vec![normalized_items]
                 }
                 GroupImportsTactic::StdExternalCrate => group_imports(normalized_items),
+                GroupImportsTactic::Wildcards(w) => group_imports_custom(w, normalized_items),
             };
 
             if context.config.reorder_imports() {
@@ -170,6 +171,28 @@ fn contains_macro_use_attr(item: &ast::Item) -> bool {
     attr::contains_name(&item.attrs, sym::macro_use)
 }
 
+fn group_imports_custom(wildcards: WildcardGroups, uts: Vec<UseTree>) -> Vec<Vec<UseTree>> {
+    let mut groups = vec![vec![]; wildcards.len() + 1];
+    let fallback_group = groups.len() - 1;
+
+    for ut in uts.into_iter() {
+        let ut_path_str = ut.to_string();
+        if ut.path.is_empty() {
+            groups[fallback_group].push(ut);
+            continue;
+        }
+
+        if let Some(idx) = wildcards.iter().position(|w| w.matches(&ut_path_str)) {
+            groups[idx].push(ut);
+            continue;
+        }
+
+        groups[fallback_group].push(ut);
+    }
+
+    groups
+}
+
 /// Divides imports into three groups, corresponding to standard, external
 /// and local imports. Sorts each subgroup.
 fn group_imports(uts: Vec<UseTree>) -> Vec<Vec<UseTree>> {

tests/config/wildcard-base.toml

@@ -0,0 +1,7 @@
+group_imports = [
+    ["a", "b::c"],
+    ["$crate::x::*"],
+    ["$std::sync"],
+    ["*::ipsum::*"],
+    ["xyz::abc::dez"],
+]

tests/config/wildcard-example.rs

@@ -0,0 +1,5 @@
+group_imports = [
+    ["$std::*", "proc_macro::*"],
+    ["my_crate::*", "crate::*::xyz"],
+    ["$crate::*"],
+]

tests/source/wildcard-group-import/config-example.rs

@@ -0,0 +1,10 @@
+// rustfmt-unstable: true
+// rustfmt-config: wildcard-example.rs
+use self::X;
+use super::Y;
+use crate::abc::xyz;
+use crate::Z;
+use my_crate::a::B;
+use my_crate::A;
+use proc_macro::Span;
+use std::rc::Rc;

tests/source/wildcard-group-import/import.rs

@@ -0,0 +1,14 @@
+// rustfmt-unstable: true
+// rustfmt-config: wildcard-base.toml
+use self::x;
+use crate::x::y;
+use crate::y;
+use a;
+use a::ipsum::b;
+use b::c;
+use b::c::d;
+use c::d::ipsum::b;
+use core::sync;
+use core::sync::A;
+use std::sync;
+use xyz::abc::dez;

tests/target/wildcard-group-import/config-example.rs

@@ -0,0 +1,12 @@
+// rustfmt-unstable: true
+// rustfmt-config: wildcard-example.rs
+use proc_macro::Span;
+use std::rc::Rc;
+
+use crate::abc::xyz;
+use my_crate::a::B;
+use my_crate::A;
+
+use self::X;
+use super::Y;
+use crate::Z;

tests/target/wildcard-group-import/import.rs

@@ -0,0 +1,19 @@
+// rustfmt-unstable: true
+// rustfmt-config: wildcard-base.toml
+use a;
+use b::c;
+
+use crate::x::y;
+
+use core::sync;
+use std::sync;
+
+use a::ipsum::b;
+use c::d::ipsum::b;
+
+use xyz::abc::dez;
+
+use self::x;
+use crate::y;
+use b::c::d;
+use core::sync::A;