feat: support custom fallback group for wildcards in group_imports

Author: utkarshgupta137

Configurations.md

@@ -2307,6 +2307,7 @@ For a given config:
 ```toml
 group_imports = [
     ["$std::*", "proc_macro::*"],
+    ["*"],
     ["my_crate::*", "crate::*::xyz"],
     ["$crate::*"],
 ]
@@ -2318,6 +2319,8 @@ The following order would be set:
 use proc_macro::Span;
 use std::rc::Rc;
 
+use rand;
+
 use crate::abc::xyz;
 use my_crate::a::B;
 use my_crate::A;
@@ -2375,7 +2378,7 @@ specific version of rustfmt is used in your CI, use this option.
 
 The width threshold for an array element to be considered "short".
 
-The layout of an array is dependent on the length of each of its elements. 
+The layout of an array is dependent on the length of each of its elements.
 If the length of every element in an array is below this threshold (all elements are "short") then the array can be formatted in the mixed/compressed style, but if any one element has a length that exceeds this threshold then the array elements will have to be formatted vertically.
 
 - **Default value**: `10`

src/config/options.rs

@@ -145,7 +145,12 @@ impl Serialize for GroupImportsTactic {
             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())
+                    .map(|w| match w {
+                        WildcardGroup::Group(res) => {
+                            res.iter().map(|l| l.as_str().to_string()).collect()
+                        }
+                        WildcardGroup::Fallback => vec!["*".to_owned()],
+                    })
                     .collect(),
             )
             .serialize(serializer),
@@ -222,11 +227,21 @@ impl fmt::Display for WildcardGroups {
 }
 
 #[derive(Debug, Clone)]
-pub struct WildcardGroup(Vec<regex::Regex>);
+pub enum WildcardGroup {
+    Group(Vec<regex::Regex>),
+    Fallback,
+}
 
 impl WildcardGroup {
+    pub(crate) fn is_fallback(&self) -> bool {
+        self == &Self::Fallback
+    }
+
     pub(crate) fn matches(&self, path: &str) -> bool {
-        self.0.iter().any(|w| w.is_match(path))
+        match self {
+            Self::Group(res) => res.iter().any(|w| w.is_match(path)),
+            Self::Fallback => false,
+        }
     }
 }
 
@@ -239,6 +254,10 @@ impl TryFrom<Vec<String>> for WildcardGroup {
             Crate,
         }
 
+        if i == vec!["*"] {
+            return Ok(Self::Fallback);
+        }
+
         i.into_iter()
             .map(|s| {
                 let (s, kind) = if let Some(tail) = s.strip_prefix("$std") {
@@ -260,22 +279,27 @@ impl TryFrom<Vec<String>> for WildcardGroup {
                 regex::Regex::new(&format!("^{wildcard}$"))
             })
             .collect::<Result<_, _>>()
-            .map(Self)
+            .map(Self::Group)
     }
 }
 
 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;
-        }
+        match (self, other) {
+            (Self::Fallback, Self::Fallback) => true,
+            (Self::Group(left), Self::Group(right)) => {
+                if left.len() != right.len() {
+                    return false;
+                }
 
-        self.0
-            .iter()
-            .zip(other.0.iter())
-            .all(|(a, b)| a.as_str() == b.as_str())
+                left.iter()
+                    .zip(right.iter())
+                    .all(|(a, b)| a.as_str() == b.as_str())
+            }
+            (_, _) => false,
+        }
     }
 }
 

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, WildcardGroups};
+use crate::config::{Config, GroupImportsTactic, WildcardGroup, 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};
@@ -173,7 +173,10 @@ fn contains_macro_use_attr(item: &ast::Item) -> bool {
 
 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;
+    let fallback_group = wildcards
+        .iter()
+        .position(WildcardGroup::is_fallback)
+        .unwrap_or(groups.len() - 1);
 
     for ut in uts.into_iter() {
         let ut_path_str = ut.to_string();

tests/config/wildcard-example.rs renamed to tests/config/wildcard-example.toml

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

tests/config/wildcard-fallback.toml

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

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

@@ -1,10 +1,11 @@
 // rustfmt-unstable: true
-// rustfmt-config: wildcard-example.rs
+// rustfmt-config: wildcard-example.toml
 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 rand;
 use std::rc::Rc;

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

@@ -0,0 +1,14 @@
+// rustfmt-unstable: true
+// rustfmt-config: wildcard-fallback.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

@@ -1,8 +1,10 @@
 // rustfmt-unstable: true
-// rustfmt-config: wildcard-example.rs
+// rustfmt-config: wildcard-example.toml
 use proc_macro::Span;
 use std::rc::Rc;
 
+use rand;
+
 use crate::abc::xyz;
 use my_crate::a::B;
 use my_crate::A;

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

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