From 3f6dc20d3cf3fa101552a9067b98a1314260a679 Mon Sep 17 00:00:00 2001 From: Aleksey Kladov Date: Wed, 18 Mar 2020 16:41:24 +0100 Subject: Merge imports assist Work towards #2220 --- crates/ra_assists/src/handlers/merge_imports.rs | 154 ++++++++++++++++++++++++ crates/ra_assists/src/handlers/move_bounds.rs | 4 +- crates/ra_assists/src/handlers/split_import.rs | 29 +---- 3 files changed, 162 insertions(+), 25 deletions(-) create mode 100644 crates/ra_assists/src/handlers/merge_imports.rs (limited to 'crates/ra_assists/src/handlers') diff --git a/crates/ra_assists/src/handlers/merge_imports.rs b/crates/ra_assists/src/handlers/merge_imports.rs new file mode 100644 index 000000000..96b1ab86a --- /dev/null +++ b/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 { + 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 { + this_use_item.syntax().siblings(direction).skip(1).find_map(ast::UseItem::cast) +} + +fn try_merge_trees(old: &ast::UseTree, new: &ast::UseTree) -> Option { + 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 = 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}}; +", + ) + } +} diff --git a/crates/ra_assists/src/handlers/move_bounds.rs b/crates/ra_assists/src/handlers/move_bounds.rs index 0b501f3e5..342a770ec 100644 --- a/crates/ra_assists/src/handlers/move_bounds.rs +++ b/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 { (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 = { diff --git a/crates/ra_assists/src/handlers/split_import.rs b/crates/ra_assists/src/handlers/split_import.rs index 292c39f59..d9244f22d 100644 --- a/crates/ra_assists/src/handlers/split_import.rs +++ b/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 { 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 { }) } -fn split_use_tree_prefix(use_tree: &ast::UseTree, prefix: &ast::Path) -> Option { - 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 { - 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}; -- cgit v1.2.3