Implement One option for imports_granularity (rust-lang#4669)

This option merges all imports into a single `use` statement as long as
they have the same visibility.

Author: magurotuna

Configurations.md

@@ -1710,7 +1710,7 @@ pub enum Foo {}
 Merge together related imports based on their paths.
 
 - **Default value**: `Preserve`
-- **Possible values**: `Preserve`, `Crate`, `Module`, `Item`
+- **Possible values**: `Preserve`, `Crate`, `Module`, `Item`, `One`
 - **Stable**: No
 
 #### `Preserve` (default):
@@ -1764,6 +1764,23 @@ use qux::h;
 use qux::i;
 ```
 
+#### `One`:
+
+Merge all imports into a single `use` statement as long as they have the same visibility.
+
+```rust
+pub use foo::{x, y};
+use {
+    bar::{
+        a, b,
+        b::{f, g},
+        c,
+        d::e,
+    },
+    qux::{h, i},
+};
+```
+
 ## `merge_imports`
 
 This option is deprecated. Use `imports_granularity = "Crate"` instead.

src/config/options.rs

@@ -130,6 +130,8 @@ pub enum ImportGranularity {
     Module,
     /// Use one `use` statement per imported item.
     Item,
+    /// Use one `use` statement including all items.
+    One,
 }
 
 #[config_type]

src/formatting/imports.rs

@@ -166,6 +166,15 @@ impl UseSegment {
 
 pub(crate) fn merge_use_trees(use_trees: Vec<UseTree>, merge_by: SharedPrefix) -> Vec<UseTree> {
     let mut result = Vec::with_capacity(use_trees.len());
+
+    // If `merge_by` is `SharedPrefix::One`, we firstly compute the result as if it's
+    // `SharedPrefix::Crate`, and then merge the result one more time.
+    let temp_merge_by = if merge_by == SharedPrefix::One {
+        SharedPrefix::Crate
+    } else {
+        merge_by
+    };
+
     for use_tree in use_trees {
         if use_tree.has_comment() || use_tree.attrs.is_some() {
             result.push(use_tree);
@@ -187,14 +196,19 @@ pub(crate) fn merge_use_trees(use_trees: Vec<UseTree>, merge_by: SharedPrefix) -
             }
             if let Some(tree) = result
                 .iter_mut()
-                .find(|tree| tree.share_prefix(&flattened, merge_by))
+                .find(|tree| tree.share_prefix(&flattened, temp_merge_by))
             {
-                tree.merge(&flattened, merge_by);
+                tree.merge(&flattened, temp_merge_by);
             } else {
                 result.push(flattened);
             }
         }
     }
+
+    if merge_by == SharedPrefix::One {
+        result = merge_use_trees_into_one(result);
+    }
+
     result
 }
 
@@ -579,6 +593,7 @@ impl UseTree {
                 SharedPrefix::Module => {
                     self.path[..self.path.len() - 1] == other.path[..other.path.len() - 1]
                 }
+                SharedPrefix::One => unreachable!(),
             }
         }
     }
@@ -692,6 +707,39 @@ fn merge_use_trees_inner(trees: &mut Vec<UseTree>, use_tree: UseTree, merge_by:
     trees.sort();
 }
 
+fn merge_use_trees_into_one(trees: Vec<UseTree>) -> Vec<UseTree> {
+    let mut result = vec![];
+    for mut tree in trees {
+        if tree.attrs.is_some() {
+            result.push(tree);
+        } else if let Some(UseSegment::List(list)) = result.iter_mut().find_map(|r| {
+            if r.same_visibility(&tree) && r.attrs.is_none() {
+                r.path.get_mut(0)
+            } else {
+                None
+            }
+        }) {
+            list.push(tree);
+        } else {
+            tree.path = vec![UseSegment::List(vec![tree.clone()])];
+            result.push(tree);
+        }
+    }
+
+    // As a result of merging into one, if a `UseTree` has only one crate path just like
+    // `use {a::{b, c}}`, outmost curly braces can be removed.
+    for r in result.iter_mut() {
+        match r.path.get(0) {
+            Some(UseSegment::List(list)) if r.path.len() == 1 && list.len() == 1 => {
+                *r = list[0].clone();
+            }
+            _ => {}
+        }
+    }
+
+    result
+}
+
 impl Hash for UseTree {
     fn hash<H: Hasher>(&self, state: &mut H) {
         self.path.hash(state);
@@ -897,6 +945,7 @@ impl Rewrite for UseTree {
 pub(crate) enum SharedPrefix {
     Crate,
     Module,
+    One,
 }
 
 #[cfg(test)]
@@ -1111,6 +1160,25 @@ mod test {
         );
     }
 
+    #[test]
+    fn test_use_tree_merge_one() {
+        test_merge!(One, ["a", "b"], ["{a, b}"]);
+
+        test_merge!(
+            One,
+            ["a", "a::{aa, ab::{aba, abb}}"],
+            ["a::{self, aa, ab::{aba, abb}}"]
+        );
+
+        test_merge!(One, ["a", "b::{ba, *}"], ["{a, b::{ba, *}}"]);
+
+        test_merge!(
+            One,
+            ["a", "b::{ba, bb}", "a::{aa::*, ab::aba}"],
+            ["{a::{self, aa::*, ab::aba}, b::{ba, bb}}"]
+        );
+    }
+
     #[test]
     fn test_flatten_use_trees() {
         assert_eq!(

src/formatting/reorder.rs

@@ -234,6 +234,7 @@ fn rewrite_reorderable_or_regroupable_items(
                     merge_use_trees(normalized_items, SharedPrefix::Module)
                 }
                 ImportGranularity::Item => flatten_use_trees(normalized_items),
+                ImportGranularity::One => merge_use_trees(normalized_items, SharedPrefix::One),
                 ImportGranularity::Preserve => normalized_items,
             };
 

tests/source/imports_granularity_one.rs

@@ -0,0 +1,32 @@
+// rustfmt-imports_granularity: One
+
+use a;
+
+use a;
+use b;
+
+use a;
+use a::{ab, aa::aaa};
+
+use a::aa;
+use a::ab::{aba, abb};
+use b::ba::{baa as foo, bab};
+
+use a::aa;
+#[cfg(test)]
+use a::{ab, ac::aca};
+#[cfg(test)]
+use b::{ba, bb, bc::bca::{bcaa, bcab}};
+use a::ad::ada;
+use b;
+
+pub use a::aa;
+use a::{ab, ac, ad};
+pub use a::ae;
+use b::ba;
+pub use b::{bb, bc::bca};
+
+use a::{aa::*, ab};
+use b::{bb::{self, bba}, ba};
+use a::ac::{acb, aca};
+use a::aa::aaa;

tests/target/imports_granularity_one.rs

@@ -0,0 +1,48 @@
+// rustfmt-imports_granularity: One
+
+use a;
+
+use {a, b};
+
+use a::{self, aa::aaa, ab};
+
+use {
+    a::{
+        aa,
+        ab::{aba, abb},
+    },
+    b::ba::{baa as foo, bab},
+};
+
+#[cfg(test)]
+use a::{ab, ac::aca};
+#[cfg(test)]
+use b::{
+    ba, bb,
+    bc::bca::{bcaa, bcab},
+};
+use {
+    a::{aa, ad::ada},
+    b,
+};
+
+pub use {
+    a::{aa, ae},
+    b::{bb, bc::bca},
+};
+use {
+    a::{ab, ac, ad},
+    b::ba,
+};
+
+use {
+    a::{
+        aa::{aaa, *},
+        ab,
+        ac::{aca, acb},
+    },
+    b::{
+        ba,
+        bb::{self, bba},
+    },
+};