Make merge_imports more granular with a Module option.

Author: goffrie

Configurations.md

@@ -1707,26 +1707,43 @@ pub enum Foo {}
 
 ## `merge_imports`
 
-Merge multiple imports into a single nested import.
+Merge together related imports based on their paths.
 
-- **Default value**: `false`
-- **Possible values**: `true`, `false`
+This option requires `reorder_imports`, which is enabled by default.
+
+- **Default value**: `Never`
+- **Possible values**: `Never`, `Crate`, `Module`
 - **Stable**: No (tracking issue: [#3362](https://github.com/rust-lang/rustfmt/issues/3362))
 
-#### `false` (default):
+#### `Never` (default):
 
 ```rust
-use foo::{a, c, d};
-use foo::{b, g};
-use foo::{e, f};
+use foo::b;
+use foo::b::{f, g};
+use foo::{a, c, d::e};
+use qux::{h, i};
 ```
 
-#### `true`:
+#### `Crate`:
 
 ```rust
-use foo::{a, b, c, d, e, f, g};
+use foo::{
+    a, b,
+    b::{f, g},
+    c,
+    d::e,
+};
+use qux::{h, i};
 ```
 
+#### `Module`:
+
+```rust
+use foo::b::{f, g};
+use foo::d::e;
+use foo::{a, b, c};
+use qux::{h, i};
+```
 
 ## `newline_style`
 
@@ -2560,7 +2577,7 @@ Enable unstable features on stable and beta channels (unstable features are avai
 
 For example:
 ```bash
-rustfmt src/lib.rs --config unstable_features=true merge_imports=true
+rustfmt src/lib.rs --config unstable_features=true merge_imports=Crate
 ```
 
 ## `use_field_init_shorthand`

src/config.rs

@@ -77,7 +77,7 @@ create_config! {
     // Imports
     imports_indent: IndentStyle, IndentStyle::Block, false, "Indent of imports";
     imports_layout: ListTactic, ListTactic::Mixed, false, "Item layout inside a import block";
-    merge_imports: bool, false, false, "Merge imports";
+    merge_imports: MergeImports, MergeImports::Never, false, "Merge imports";
     group_imports: GroupImportsTactic, GroupImportsTactic::Preserve, false,
         "Controls the strategy for how imports are grouped together";
 
@@ -595,7 +595,7 @@ fn_single_line = false
 where_single_line = false
 imports_indent = "Block"
 imports_layout = "Mixed"
-merge_imports = false
+merge_imports = "Never"
 group_imports = "Preserve"
 reorder_imports = true
 reorder_modules = true
@@ -716,13 +716,13 @@ ignore = []
             }
             let toml = r#"
                 unstable_features = true
-                merge_imports = true
+                merge_imports = "Crate"
             "#;
             let config = Config::from_toml(toml, Path::new("")).unwrap();
             assert_eq!(config.was_set().unstable_features(), true);
             assert_eq!(config.was_set().merge_imports(), true);
             assert_eq!(config.unstable_features(), true);
-            assert_eq!(config.merge_imports(), true);
+            assert_eq!(config.merge_imports(), MergeImports::Crate);
         }
 
         #[test]
@@ -731,9 +731,9 @@ ignore = []
                 // This test requires non-nightly
                 return;
             }
-            let config = Config::from_toml("merge_imports = true", Path::new("")).unwrap();
+            let config = Config::from_toml("merge_imports = Crate", Path::new("")).unwrap();
             assert_eq!(config.was_set().merge_imports(), false);
-            assert_eq!(config.merge_imports(), false);
+            assert_eq!(config.merge_imports(), MergeImports::Never);
         }
 
         #[test]
@@ -778,12 +778,12 @@ ignore = []
             }
             let mut config = Config::default();
             assert_eq!(config.unstable_features(), false);
-            config.override_value("merge_imports", "true");
-            assert_eq!(config.merge_imports(), false);
+            config.override_value("merge_imports", "Crate");
+            assert_eq!(config.merge_imports(), MergeImports::Crate);
             config.override_value("unstable_features", "true");
             assert_eq!(config.unstable_features(), true);
-            config.override_value("merge_imports", "true");
-            assert_eq!(config.merge_imports(), true);
+            config.override_value("merge_imports", "Crate");
+            assert_eq!(config.merge_imports(), MergeImports::Crate);
         }
 
         #[test]

src/config/options.rs

@@ -118,6 +118,17 @@ pub enum GroupImportsTactic {
     StdExternalCrate,
 }
 
+#[config_type]
+/// How to merge imports.
+pub enum MergeImports {
+    /// Do not merge imports.
+    Never,
+    /// Use one `use` statement per crate.
+    Crate,
+    /// Use one `use` statement per module.
+    Module,
+}
+
 #[config_type]
 pub enum ReportTactic {
     Always,

src/formatting/imports.rs

@@ -179,6 +179,48 @@ pub(crate) fn merge_use_trees(use_trees: Vec<UseTree>) -> Vec<UseTree> {
     result
 }
 
+/// Split apart nested imports in use trees.
+pub(crate) fn unnest_use_trees(mut use_trees: Vec<UseTree>) -> Vec<UseTree> {
+    let mut result = Vec::with_capacity(use_trees.len());
+    while let Some(mut use_tree) = use_trees.pop() {
+        if !use_tree.has_comment() && use_tree.attrs.is_none() {
+            if let Some((UseSegment::List(list), ref prefix)) = use_tree.path.split_last_mut() {
+                let span = use_tree.span;
+                let visibility = &use_tree.visibility;
+                list.retain(|nested_use_tree| {
+                    if matches!(
+                        nested_use_tree.path[..],
+                        [UseSegment::Ident(..)] | [UseSegment::Slf(..)] | [UseSegment::Glob]
+                    ) {
+                        return true;
+                    }
+                    if nested_use_tree.has_comment() {
+                        return true;
+                    }
+                    // nested item detected; flatten once, but process it again
+                    // in case it has more nesting
+                    use_trees.push(UseTree {
+                        path: prefix
+                            .iter()
+                            .cloned()
+                            .chain(nested_use_tree.path.iter().cloned())
+                            .collect(),
+                        span,
+                        list_item: None,
+                        visibility: visibility.clone(),
+                        attrs: None,
+                    });
+                    // remove this item
+                    false
+                });
+                use_tree = use_tree.normalize();
+            }
+        }
+        result.push(use_tree);
+    }
+    result
+}
+
 impl fmt::Debug for UseTree {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         fmt::Display::fmt(self, f)

src/formatting/reorder.rs

@@ -11,11 +11,11 @@ use std::cmp::{Ord, Ordering};
 use rustc_ast::ast;
 use rustc_span::{symbol::sym, Span};
 
-use crate::config::{Config, GroupImportsTactic};
+use crate::config::{Config, GroupImportsTactic, MergeImports};
 use crate::formatting::imports::UseSegment;
 use crate::formatting::modules::{get_mod_inner_attrs, FileModMap};
 use crate::formatting::{
-    imports::{merge_use_trees, UseTree},
+    imports::{merge_use_trees, unnest_use_trees, UseTree},
     items::{is_mod_decl, rewrite_extern_crate, rewrite_mod},
     lists::{itemize_list, write_list, ListFormatting, ListItem},
     rewrite::RewriteContext,
@@ -226,8 +226,12 @@ fn rewrite_reorderable_or_regroupable_items(
             for (item, list_item) in normalized_items.iter_mut().zip(list_items) {
                 item.list_item = Some(list_item.clone());
             }
-            if context.config.merge_imports() {
-                normalized_items = merge_use_trees(normalized_items);
+            match context.config.merge_imports() {
+                MergeImports::Crate => normalized_items = merge_use_trees(normalized_items),
+                MergeImports::Module => {
+                    normalized_items = unnest_use_trees(merge_use_trees(normalized_items))
+                }
+                MergeImports::Never => {}
             }
 
             let mut regrouped_items = match context.config.group_imports() {

src/rustfmt/main.rs

@@ -100,7 +100,7 @@ struct Opt {
     /// Set options from command line.
     ///
     /// Set configuration options via command line by specifying a list of key-value pairs
-    /// separated by commas (e.g., rustfmt --config=max_width=100,merge_imports=true).
+    /// separated by commas (e.g., rustfmt --config=max_width=100,merge_imports=Crate).
     /// These settings precedes any other settings specified in configuration files.
     #[structopt(long = "config")]
     inline_config: Option<Vec<InlineConfig>>,

tests/source/configs/group_imports/StdExternalCrate-merge_imports.rs

@@ -1,5 +1,5 @@
 // rustfmt-group_imports: StdExternalCrate
-// rustfmt-merge_imports: true
+// rustfmt-merge_imports: Crate
 use chrono::Utc;
 use super::update::convert_publish_payload;
 

tests/source/configs/imports_layout/merge_mixed.rs

@@ -1,5 +1,5 @@
 // rustfmt-imports_indent: Block
-// rustfmt-merge_imports: true
+// rustfmt-merge_imports: Crate
 // rustfmt-imports_layout: Mixed
 
 use std::{fmt, io, str};

tests/source/issue-3750.rs

@@ -1,4 +1,4 @@
-// rustfmt-merge_imports: true
+// rustfmt-merge_imports: Crate
 
 pub mod foo {
     pub mod bar {

tests/source/merge_imports.rs tests/source/merge_imports_crate.rstests/source/merge_imports.rs renamed to tests/source/merge_imports_crate.rs

@@ -1,4 +1,4 @@
-// rustfmt-merge_imports: true
+// rustfmt-merge_imports: Crate
 
 use a::{c,d,b};
 use a::{d, e, b, a, f};