Merge #3640

3640: Merge imports assist r=matklad a=matklad

Work towards #2220



bors r+
🤖

Co-authored-by: Aleksey Kladov <[email protected]>

Author: bors[bot]

crates/ra_assists/src/doc_tests/generated.rs

@@ -417,6 +417,20 @@ fn main() {
     )
 }
 
+#[test]
+fn doctest_merge_imports() {
+    check(
+        "merge_imports",
+        r#####"
+use std::<|>fmt::Formatter;
+use std::io;
+"#####,
+        r#####"
+use std::{fmt::Formatter, io};
+"#####,
+    )
+}
+
 #[test]
 fn doctest_merge_match_arms() {
     check(

crates/ra_assists/src/handlers/merge_imports.rs

@@ -0,0 +1,154 @@
+use std::iter::successors;
+
+use ast::{edit::AstNodeEdit, make};
+use ra_syntax::{ast, AstNode, AstToken, Direction, InsertPosition, SyntaxElement, T};
+
+use crate::{Assist, AssistCtx, AssistId};
+
+// Assist: merge_imports
+//
+// Merges two imports with a common prefix.
+//
+// ```
+// use std::<|>fmt::Formatter;
+// use std::io;
+// ```
+// ->
+// ```
+// use std::{fmt::Formatter, io};
+// ```
+pub(crate) fn merge_imports(ctx: AssistCtx) -> Option<Assist> {
+    let tree: ast::UseTree = ctx.find_node_at_offset()?;
+    let use_item = tree.syntax().parent().and_then(ast::UseItem::cast)?;
+    let (merged, to_delete) = [Direction::Prev, Direction::Next]
+        .iter()
+        .copied()
+        .filter_map(|dir| next_use_item(&use_item, dir))
+        .filter_map(|it| Some((it.clone(), it.use_tree()?)))
+        .find_map(|(use_item, use_tree)| {
+            Some((try_merge_trees(&tree, &use_tree)?, use_item.clone()))
+        })?;
+    let mut offset = ctx.frange.range.start();
+    ctx.add_assist(AssistId("merge_imports"), "Merge imports", |edit| {
+        edit.replace_ast(tree, merged);
+
+        let mut range = to_delete.syntax().text_range();
+        let next_ws = to_delete
+            .syntax()
+            .next_sibling_or_token()
+            .and_then(|it| it.into_token())
+            .and_then(ast::Whitespace::cast);
+        if let Some(ws) = next_ws {
+            range = range.extend_to(&ws.syntax().text_range())
+        }
+        edit.delete(range);
+        if range.end() <= offset {
+            offset -= range.len();
+        }
+        edit.set_cursor(offset);
+    })
+}
+
+fn next_use_item(this_use_item: &ast::UseItem, direction: Direction) -> Option<ast::UseItem> {
+    this_use_item.syntax().siblings(direction).skip(1).find_map(ast::UseItem::cast)
+}
+
+fn try_merge_trees(old: &ast::UseTree, new: &ast::UseTree) -> Option<ast::UseTree> {
+    let lhs_path = old.path()?;
+    let rhs_path = new.path()?;
+
+    let (lhs_prefix, rhs_prefix) = common_prefix(&lhs_path, &rhs_path)?;
+
+    let lhs = old.split_prefix(&lhs_prefix);
+    let rhs = new.split_prefix(&rhs_prefix);
+
+    let mut to_insert: Vec<SyntaxElement> = Vec::new();
+    to_insert.push(make::token(T![,]).into());
+    to_insert.push(make::tokens::single_space().into());
+    to_insert.extend(
+        rhs.use_tree_list()?
+            .syntax()
+            .children_with_tokens()
+            .filter(|it| it.kind() != T!['{'] && it.kind() != T!['}']),
+    );
+    let use_tree_list = lhs.use_tree_list()?;
+    let pos = InsertPosition::Before(use_tree_list.r_curly()?.into());
+    let use_tree_list = use_tree_list.insert_children(pos, to_insert);
+    Some(lhs.with_use_tree_list(use_tree_list))
+}
+
+fn common_prefix(lhs: &ast::Path, rhs: &ast::Path) -> Option<(ast::Path, ast::Path)> {
+    let mut res = None;
+    let mut lhs_curr = first_path(&lhs);
+    let mut rhs_curr = first_path(&rhs);
+    loop {
+        match (lhs_curr.segment(), rhs_curr.segment()) {
+            (Some(lhs), Some(rhs)) if lhs.syntax().text() == rhs.syntax().text() => (),
+            _ => break,
+        }
+        res = Some((lhs_curr.clone(), rhs_curr.clone()));
+
+        match (lhs_curr.parent_path(), rhs_curr.parent_path()) {
+            (Some(lhs), Some(rhs)) => {
+                lhs_curr = lhs;
+                rhs_curr = rhs;
+            }
+            _ => break,
+        }
+    }
+
+    res
+}
+
+fn first_path(path: &ast::Path) -> ast::Path {
+    successors(Some(path.clone()), |it| it.qualifier()).last().unwrap()
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::helpers::check_assist;
+
+    use super::*;
+
+    #[test]
+    fn test_merge_first() {
+        check_assist(
+            merge_imports,
+            r"
+use std::fmt<|>::Debug;
+use std::fmt::Display;
+",
+            r"
+use std::fmt<|>::{Debug, Display};
+",
+        )
+    }
+
+    #[test]
+    fn test_merge_second() {
+        check_assist(
+            merge_imports,
+            r"
+use std::fmt::Debug;
+use std::fmt<|>::Display;
+",
+            r"
+use std::fmt<|>::{Display, Debug};
+",
+        )
+    }
+
+    #[test]
+    #[ignore]
+    fn test_merge_nested() {
+        check_assist(
+            merge_imports,
+            r"
+use std::{fmt<|>::Debug, fmt::Display};
+",
+            r"
+use std::{fmt::{Debug, Display}};
+",
+        )
+    }
+}

crates/ra_assists/src/handlers/move_bounds.rs

@@ -1,5 +1,5 @@
 use ra_syntax::{
-    ast::{self, edit, make, AstNode, NameOwner, TypeBoundsOwner},
+    ast::{self, edit::AstNodeEdit, make, AstNode, NameOwner, TypeBoundsOwner},
     SyntaxElement,
     SyntaxKind::*,
 };
@@ -54,7 +54,7 @@ pub(crate) fn move_bounds_to_where_clause(ctx: AssistCtx) -> Option<Assist> {
                 (type_param, without_bounds)
             });
 
-        let new_type_param_list = edit::replace_descendants(&type_param_list, new_params);
+        let new_type_param_list = type_param_list.replace_descendants(new_params);
         edit.replace_ast(type_param_list.clone(), new_type_param_list);
 
         let where_clause = {

crates/ra_assists/src/handlers/split_import.rs

@@ -1,9 +1,6 @@
-use std::iter::{once, successors};
+use std::iter::successors;
 
-use ra_syntax::{
-    ast::{self, make},
-    AstNode, T,
-};
+use ra_syntax::{ast, AstNode, T};
 
 use crate::{Assist, AssistCtx, AssistId};
 
@@ -25,7 +22,10 @@ pub(crate) fn split_import(ctx: AssistCtx) -> Option<Assist> {
 
     let use_tree = top_path.syntax().ancestors().find_map(ast::UseTree::cast)?;
 
-    let new_tree = split_use_tree_prefix(&use_tree, &path)?;
+    let new_tree = use_tree.split_prefix(&path);
+    if new_tree == use_tree {
+        return None;
+    }
     let cursor = ctx.frange.range.start();
 
     ctx.add_assist(AssistId("split_import"), "Split import", |edit| {
@@ -35,23 +35,6 @@ pub(crate) fn split_import(ctx: AssistCtx) -> Option<Assist> {
     })
 }
 
-fn split_use_tree_prefix(use_tree: &ast::UseTree, prefix: &ast::Path) -> Option<ast::UseTree> {
-    let suffix = split_path_prefix(&prefix)?;
-    let use_tree = make::use_tree(suffix.clone(), use_tree.use_tree_list(), use_tree.alias());
-    let nested = make::use_tree_list(once(use_tree));
-    let res = make::use_tree(prefix.clone(), Some(nested), None);
-    Some(res)
-}
-
-fn split_path_prefix(prefix: &ast::Path) -> Option<ast::Path> {
-    let parent = prefix.parent_path()?;
-    let mut res = make::path_unqualified(parent.segment()?);
-    for p in successors(parent.parent_path(), |it| it.parent_path()) {
-        res = make::path_qualified(res, p.segment()?);
-    }
-    Some(res)
-}
-
 #[cfg(test)]
 mod tests {
     use crate::helpers::{check_assist, check_assist_target};

crates/ra_assists/src/lib.rs

@@ -110,6 +110,7 @@ mod handlers {
     mod inline_local_variable;
     mod introduce_variable;
     mod invert_if;
+    mod merge_imports;
     mod merge_match_arms;
     mod move_bounds;
     mod move_guard;
@@ -140,6 +141,7 @@ mod handlers {
             inline_local_variable::inline_local_variable,
             introduce_variable::introduce_variable,
             invert_if::invert_if,
+            merge_imports::merge_imports,
             merge_match_arms::merge_match_arms,
             move_bounds::move_bounds_to_where_clause,
             move_guard::move_arm_cond_to_match_guard,