From e4756cb4f6e66097638b9d101589358976be2ba8 Mon Sep 17 00:00:00 2001 From: Chetan Khilosiya Date: Tue, 23 Feb 2021 00:17:48 +0530 Subject: 7526: Rename crate assists to ide_assists. --- .../handlers/replace_derive_with_manual_impl.rs | 404 --------------------- 1 file changed, 404 deletions(-) delete mode 100644 crates/assists/src/handlers/replace_derive_with_manual_impl.rs (limited to 'crates/assists/src/handlers/replace_derive_with_manual_impl.rs') diff --git a/crates/assists/src/handlers/replace_derive_with_manual_impl.rs b/crates/assists/src/handlers/replace_derive_with_manual_impl.rs deleted file mode 100644 index c69bc5cac..000000000 --- a/crates/assists/src/handlers/replace_derive_with_manual_impl.rs +++ /dev/null @@ -1,404 +0,0 @@ -use ide_db::helpers::mod_path_to_ast; -use ide_db::imports_locator; -use itertools::Itertools; -use syntax::{ - ast::{self, make, AstNode, NameOwner}, - SyntaxKind::{IDENT, WHITESPACE}, - TextSize, -}; - -use crate::{ - assist_context::{AssistBuilder, AssistContext, Assists}, - utils::{ - add_trait_assoc_items_to_impl, filter_assoc_items, generate_trait_impl_text, - render_snippet, Cursor, DefaultMethods, - }, - AssistId, AssistKind, -}; - -// Assist: replace_derive_with_manual_impl -// -// Converts a `derive` impl into a manual one. -// -// ``` -// # trait Debug { fn fmt(&self, f: &mut Formatter) -> Result<()>; } -// #[derive(Deb$0ug, Display)] -// struct S; -// ``` -// -> -// ``` -// # trait Debug { fn fmt(&self, f: &mut Formatter) -> Result<()>; } -// #[derive(Display)] -// struct S; -// -// impl Debug for S { -// fn fmt(&self, f: &mut Formatter) -> Result<()> { -// ${0:todo!()} -// } -// } -// ``` -pub(crate) fn replace_derive_with_manual_impl( - acc: &mut Assists, - ctx: &AssistContext, -) -> Option<()> { - let attr = ctx.find_node_at_offset::()?; - - let has_derive = attr - .syntax() - .descendants_with_tokens() - .filter(|t| t.kind() == IDENT) - .find_map(syntax::NodeOrToken::into_token) - .filter(|t| t.text() == "derive") - .is_some(); - if !has_derive { - return None; - } - - let trait_token = ctx.token_at_offset().find(|t| t.kind() == IDENT && t.text() != "derive")?; - let trait_path = make::path_unqualified(make::path_segment(make::name_ref(trait_token.text()))); - - let adt = attr.syntax().parent().and_then(ast::Adt::cast)?; - let annotated_name = adt.name()?; - let insert_pos = adt.syntax().text_range().end(); - - let current_module = ctx.sema.scope(annotated_name.syntax()).module()?; - let current_crate = current_module.krate(); - - let found_traits = imports_locator::find_exact_imports( - &ctx.sema, - current_crate, - trait_token.text().to_string(), - ) - .filter_map(|candidate: either::Either| match candidate { - either::Either::Left(hir::ModuleDef::Trait(trait_)) => Some(trait_), - _ => None, - }) - .flat_map(|trait_| { - current_module - .find_use_path(ctx.sema.db, hir::ModuleDef::Trait(trait_)) - .as_ref() - .map(mod_path_to_ast) - .zip(Some(trait_)) - }); - - let mut no_traits_found = true; - for (trait_path, trait_) in found_traits.inspect(|_| no_traits_found = false) { - add_assist(acc, ctx, &attr, &trait_path, Some(trait_), &adt, &annotated_name, insert_pos)?; - } - if no_traits_found { - add_assist(acc, ctx, &attr, &trait_path, None, &adt, &annotated_name, insert_pos)?; - } - Some(()) -} - -fn add_assist( - acc: &mut Assists, - ctx: &AssistContext, - attr: &ast::Attr, - trait_path: &ast::Path, - trait_: Option, - adt: &ast::Adt, - annotated_name: &ast::Name, - insert_pos: TextSize, -) -> Option<()> { - let target = attr.syntax().text_range(); - let input = attr.token_tree()?; - let label = format!("Convert to manual `impl {} for {}`", trait_path, annotated_name); - let trait_name = trait_path.segment().and_then(|seg| seg.name_ref())?; - - acc.add( - AssistId("replace_derive_with_manual_impl", AssistKind::Refactor), - label, - target, - |builder| { - let impl_def_with_items = - impl_def_from_trait(&ctx.sema, annotated_name, trait_, trait_path); - update_attribute(builder, &input, &trait_name, &attr); - let trait_path = format!("{}", trait_path); - match (ctx.config.snippet_cap, impl_def_with_items) { - (None, _) => { - builder.insert(insert_pos, generate_trait_impl_text(adt, &trait_path, "")) - } - (Some(cap), None) => builder.insert_snippet( - cap, - insert_pos, - generate_trait_impl_text(adt, &trait_path, " $0"), - ), - (Some(cap), Some((impl_def, first_assoc_item))) => { - let mut cursor = Cursor::Before(first_assoc_item.syntax()); - let placeholder; - if let ast::AssocItem::Fn(ref func) = first_assoc_item { - if let Some(m) = func.syntax().descendants().find_map(ast::MacroCall::cast) - { - if m.syntax().text() == "todo!()" { - placeholder = m; - cursor = Cursor::Replace(placeholder.syntax()); - } - } - } - - builder.insert_snippet( - cap, - insert_pos, - format!("\n\n{}", render_snippet(cap, impl_def.syntax(), cursor)), - ) - } - }; - }, - ) -} - -fn impl_def_from_trait( - sema: &hir::Semantics, - annotated_name: &ast::Name, - trait_: Option, - trait_path: &ast::Path, -) -> Option<(ast::Impl, ast::AssocItem)> { - let trait_ = trait_?; - let target_scope = sema.scope(annotated_name.syntax()); - let trait_items = filter_assoc_items(sema.db, &trait_.items(sema.db), DefaultMethods::No); - if trait_items.is_empty() { - return None; - } - let impl_def = make::impl_trait( - trait_path.clone(), - make::path_unqualified(make::path_segment(make::name_ref(annotated_name.text()))), - ); - let (impl_def, first_assoc_item) = - add_trait_assoc_items_to_impl(sema, trait_items, trait_, impl_def, target_scope); - Some((impl_def, first_assoc_item)) -} - -fn update_attribute( - builder: &mut AssistBuilder, - input: &ast::TokenTree, - trait_name: &ast::NameRef, - attr: &ast::Attr, -) { - let new_attr_input = input - .syntax() - .descendants_with_tokens() - .filter(|t| t.kind() == IDENT) - .filter_map(|t| t.into_token().map(|t| t.text().to_string())) - .filter(|t| t != trait_name.text()) - .collect::>(); - let has_more_derives = !new_attr_input.is_empty(); - - if has_more_derives { - let new_attr_input = format!("({})", new_attr_input.iter().format(", ")); - builder.replace(input.syntax().text_range(), new_attr_input); - } else { - let attr_range = attr.syntax().text_range(); - builder.delete(attr_range); - - if let Some(line_break_range) = attr - .syntax() - .next_sibling_or_token() - .filter(|t| t.kind() == WHITESPACE) - .map(|t| t.text_range()) - { - builder.delete(line_break_range); - } - } -} - -#[cfg(test)] -mod tests { - use crate::tests::{check_assist, check_assist_not_applicable}; - - use super::*; - - #[test] - fn add_custom_impl_debug() { - check_assist( - replace_derive_with_manual_impl, - " -mod fmt { - pub struct Error; - pub type Result = Result<(), Error>; - pub struct Formatter<'a>; - pub trait Debug { - fn fmt(&self, f: &mut Formatter<'_>) -> Result; - } -} - -#[derive(Debu$0g)] -struct Foo { - bar: String, -} -", - " -mod fmt { - pub struct Error; - pub type Result = Result<(), Error>; - pub struct Formatter<'a>; - pub trait Debug { - fn fmt(&self, f: &mut Formatter<'_>) -> Result; - } -} - -struct Foo { - bar: String, -} - -impl fmt::Debug for Foo { - fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result { - ${0:todo!()} - } -} -", - ) - } - #[test] - fn add_custom_impl_all() { - check_assist( - replace_derive_with_manual_impl, - " -mod foo { - pub trait Bar { - type Qux; - const Baz: usize = 42; - const Fez: usize; - fn foo(); - fn bar() {} - } -} - -#[derive($0Bar)] -struct Foo { - bar: String, -} -", - " -mod foo { - pub trait Bar { - type Qux; - const Baz: usize = 42; - const Fez: usize; - fn foo(); - fn bar() {} - } -} - -struct Foo { - bar: String, -} - -impl foo::Bar for Foo { - $0type Qux; - - const Baz: usize = 42; - - const Fez: usize; - - fn foo() { - todo!() - } -} -", - ) - } - #[test] - fn add_custom_impl_for_unique_input() { - check_assist( - replace_derive_with_manual_impl, - " -#[derive(Debu$0g)] -struct Foo { - bar: String, -} - ", - " -struct Foo { - bar: String, -} - -impl Debug for Foo { - $0 -} - ", - ) - } - - #[test] - fn add_custom_impl_for_with_visibility_modifier() { - check_assist( - replace_derive_with_manual_impl, - " -#[derive(Debug$0)] -pub struct Foo { - bar: String, -} - ", - " -pub struct Foo { - bar: String, -} - -impl Debug for Foo { - $0 -} - ", - ) - } - - #[test] - fn add_custom_impl_when_multiple_inputs() { - check_assist( - replace_derive_with_manual_impl, - " -#[derive(Display, Debug$0, Serialize)] -struct Foo {} - ", - " -#[derive(Display, Serialize)] -struct Foo {} - -impl Debug for Foo { - $0 -} - ", - ) - } - - #[test] - fn test_ignore_derive_macro_without_input() { - check_assist_not_applicable( - replace_derive_with_manual_impl, - " -#[derive($0)] -struct Foo {} - ", - ) - } - - #[test] - fn test_ignore_if_cursor_on_param() { - check_assist_not_applicable( - replace_derive_with_manual_impl, - " -#[derive$0(Debug)] -struct Foo {} - ", - ); - - check_assist_not_applicable( - replace_derive_with_manual_impl, - " -#[derive(Debug)$0] -struct Foo {} - ", - ) - } - - #[test] - fn test_ignore_if_not_derive() { - check_assist_not_applicable( - replace_derive_with_manual_impl, - " -#[allow(non_camel_$0case_types)] -struct Foo {} - ", - ) - } -} -- cgit v1.2.3