Add ImportGranularity::ModuleCondensed

Configurations.md

@@ -1864,7 +1864,7 @@ Similar to other `import` related configuration options, this option operates wi
 Note that rustfmt will not modify the granularity of imports containing comments if doing so could potentially lose or misplace said comments.
 
 - **Default value**: `Preserve`
-- **Possible values**: `Preserve`, `Crate`, `Module`, `Item`, `One`
+- **Possible values**: `Preserve`, `Crate`, `Module`, `ModuleCondensed`, `Item`, `One`
 - **Stable**: No (tracking issue: [#4991](https://github.com/rust-lang/rustfmt/issues/4991))
 
 
@@ -1904,6 +1904,16 @@ use foo::{a, b, c};
 use qux::{h, i};
 ```
 
+#### `ModuleCondensed`:
+
+Like `Module`, but singleton imports are included in parent modules' `use` statements where it doesn't introduce nested braces.
+
+```rust
+use foo::b::{f, g};
+use foo::{a, b, c, d::e};
+use qux::{h, i};
+```
+
 #### `Item`:
 
 Flatten imports so that each has its own `use` statement.

src/config/options.rs

@@ -125,6 +125,11 @@ pub enum ImportGranularity {
     Crate,
     /// Use one `use` statement per module.
     Module,
+    /// Use one `use` statement per module, but merge singleton imports into
+    /// parent modules' `use` statements where it doesn't introduce nested
+    /// braces.
+    #[unstable_variant]
+    ModuleCondensed,
     /// Use one `use` statement per imported item.
     Item,
     /// Use one `use` statement including all items.

src/imports.rs

@@ -218,7 +218,7 @@ pub(crate) fn normalize_use_trees_with_granularity(
         ImportGranularity::Item => return flatten_use_trees(use_trees, ImportGranularity::Item),
         ImportGranularity::Preserve => return use_trees,
         ImportGranularity::Crate => SharedPrefix::Crate,
-        ImportGranularity::Module => SharedPrefix::Module,
+        ImportGranularity::Module | ImportGranularity::ModuleCondensed => SharedPrefix::Module,
         ImportGranularity::One => SharedPrefix::One,
     };
 
@@ -244,9 +244,65 @@ pub(crate) fn normalize_use_trees_with_granularity(
             }
         }
     }
+
+    if import_granularity == ImportGranularity::ModuleCondensed {
+        condense_use_trees(&mut result);
+    }
+
     result
 }
 
+/// Merge singleton imports into parent modules' use-trees where it does't
+/// introduce nested braces.
+fn condense_use_trees(use_trees: &mut Vec<UseTree>) {
+    // Sort by path length to put singletons after the trees into which they
+    // may be absorbed.
+    use_trees.sort_unstable_by_key(|tree| tree.path.len());
+
+    // Search for singletons back-to-front to preserve the just mentioned
+    // relative order between absorbing trees and singletons. Note that a
+    // singleton that is found and merged into _some_ tree is `swap_remove`d
+    // from the `use_trees` vector.
+    for n in (0..use_trees.len()).rev() {
+        let singleton = &use_trees[n];
+
+        if !singleton.is_singleton() || singleton.attrs.is_some() || singleton.contains_comment() {
+            continue;
+        }
+
+        let mut best_index_and_len = None;
+
+        // Search front-to-back for a tree to merge the singleton into. If
+        // multiple trees are equally good candidates, prefer the earliest one.
+        // Like above, these precautions help preserve the relative order
+        // between absorbing trees and singletons.
+        for curr_index in 0..n {
+            let curr_tree = &use_trees[curr_index];
+            let curr_len = curr_tree.shared_prefix_len(singleton);
+            if best_index_and_len.map_or(false, |(_, best_len)| best_len >= curr_len) {
+                continue;
+            }
+            if curr_len < 1
+                || !(curr_tree.is_singleton() || curr_len + 1 == curr_tree.path.len())
+                || curr_tree.attrs.is_some()
+                || curr_tree.contains_comment()
+                || !curr_tree.same_visibility(singleton)
+            {
+                continue;
+            }
+            best_index_and_len = Some((curr_index, curr_len));
+        }
+
+        if let Some((best_index, _)) = best_index_and_len {
+            let singleton = use_trees.swap_remove(n);
+            use_trees[best_index].merge(&singleton, SharedPrefix::Crate);
+        }
+    }
+
+    // Put the trees back in their preferred order.
+    use_trees.sort();
+}
+
 fn flatten_use_trees(
     use_trees: Vec<UseTree>,
     import_granularity: ImportGranularity,
@@ -669,6 +725,18 @@ impl UseTree {
         }
     }
 
+    fn shared_prefix_len(&self, other: &UseTree) -> usize {
+        let mut n = 0;
+        while n < self.path.len() && n < other.path.len() && self.path[n] == other.path[n] {
+            n += 1;
+        }
+        n
+    }
+
+    fn is_singleton(&self) -> bool {
+        !matches!(self.path.last().unwrap().kind, UseSegmentKind::List(_))
+    }
+
     fn flatten(self, import_granularity: ImportGranularity) -> Vec<UseTree> {
         if self.path.is_empty() || self.contains_comment() {
             return vec![self];

tests/source/imports/imports_granularity_module_condensed.rs

@@ -0,0 +1,47 @@
+// rustfmt-imports_granularity: ModuleCondensed
+
+use a::{b::c, d::e};
+use a::{f, g::{h, i}};
+use a::{j::{self, k::{self, l}, m}, n::{o::p, q}};
+pub use a::{r::s, t};
+use b::{c::d, self};
+
+#[cfg(test)]
+use foo::{a::b, c::d};
+use foo::e;
+
+use bar::{
+    // comment
+    a::b,
+    // more comment
+    c::d,
+    e::f,
+};
+
+use b::{f::g, h::{i, j} /* After b::h group */};
+use b::e;
+use b::{/* Before b::l group */ l::{self, m, n::o, p::*}, q};
+use b::d;
+use b::r; // After b::r
+use b::q::{self /* After b::q::self */};
+use b::u::{
+    a,
+    b,
+};
+use b::t::{
+    // Before b::t::a
+    a,
+    b,
+};
+use b::s::{
+    a,
+    b, // After b::s::b
+};
+use b::v::{
+    // Before b::v::a
+    a,
+    // Before b::v::b
+    b,
+};
+use b::t::{/* Before b::t::self */ self};
+use b::c;

tests/target/imports/imports_granularity_module_condensed.rs

@@ -0,0 +1,50 @@
+// rustfmt-imports_granularity: ModuleCondensed
+
+use a::g::{h, i};
+use a::j::k::{self, l};
+use a::j::{self, m};
+use a::n::{o::p, q};
+use a::{b::c, d::e, f};
+pub use a::{r::s, t};
+use b::{self, c::d};
+
+use foo::e;
+#[cfg(test)]
+use foo::{a::b, c::d};
+
+use bar::{
+    // comment
+    a::b,
+    // more comment
+    c::d,
+    e::f,
+};
+
+use b::q::{self /* After b::q::self */};
+use b::r; // After b::r
+use b::s::{
+    a,
+    b, // After b::s::b
+};
+use b::t::{/* Before b::t::self */ self};
+use b::t::{
+    // Before b::t::a
+    a,
+    b,
+};
+use b::u::{a, b};
+use b::v::{
+    // Before b::v::a
+    a,
+    // Before b::v::b
+    b,
+};
+use b::{c, d, e};
+use b::{
+    f::g,
+    h::{i, j}, /* After b::h group */
+};
+use b::{
+    /* Before b::l group */ l::{self, m, n::o, p::*},
+    q,
+};