352 lines
11 KiB
Rust
352 lines
11 KiB
Rust
use hir::Semantics;
|
|
use ide_db::{
|
|
base_db::{FileId, FileRange},
|
|
defs::Definition,
|
|
search::{SearchScope, UsageSearchResult},
|
|
RootDatabase,
|
|
};
|
|
use syntax::{
|
|
ast::{
|
|
self, make::impl_trait_type, HasGenericParams, HasName, HasTypeBounds, Name, NameLike,
|
|
PathType,
|
|
},
|
|
match_ast, ted, AstNode,
|
|
};
|
|
use text_edit::TextRange;
|
|
|
|
use crate::{AssistContext, AssistId, AssistKind, Assists};
|
|
|
|
// Assist: replace_named_generic_with_impl
|
|
//
|
|
// Replaces named generic with an `impl Trait` in function argument.
|
|
//
|
|
// ```
|
|
// fn new<P$0: AsRef<Path>>(location: P) -> Self {}
|
|
// ```
|
|
// ->
|
|
// ```
|
|
// fn new(location: impl AsRef<Path>) -> Self {}
|
|
// ```
|
|
pub(crate) fn replace_named_generic_with_impl(
|
|
acc: &mut Assists,
|
|
ctx: &AssistContext<'_>,
|
|
) -> Option<()> {
|
|
// finds `<P: AsRef<Path>>`
|
|
let type_param = ctx.find_node_at_offset::<ast::TypeParam>()?;
|
|
// returns `P`
|
|
let type_param_name = type_param.name()?;
|
|
|
|
// The list of type bounds / traits: `AsRef<Path>`
|
|
let type_bound_list = type_param.type_bound_list()?;
|
|
|
|
let fn_ = type_param.syntax().ancestors().find_map(ast::Fn::cast)?;
|
|
let param_list_text_range = fn_.param_list()?.syntax().text_range();
|
|
|
|
let type_param_hir_def = ctx.sema.to_def(&type_param)?;
|
|
let type_param_def = Definition::GenericParam(hir::GenericParam::TypeParam(type_param_hir_def));
|
|
|
|
// get all usage references for the type param
|
|
let usage_refs = find_usages(&ctx.sema, &fn_, type_param_def, ctx.file_id());
|
|
if usage_refs.is_empty() {
|
|
return None;
|
|
}
|
|
|
|
// All usage references need to be valid (inside the function param list)
|
|
if !check_valid_usages(&usage_refs, param_list_text_range) {
|
|
return None;
|
|
}
|
|
|
|
let mut path_types_to_replace = Vec::new();
|
|
for (_a, refs) in usage_refs.iter() {
|
|
for usage_ref in refs {
|
|
let param_node = find_path_type(&ctx.sema, &type_param_name, &usage_ref.name)?;
|
|
path_types_to_replace.push(param_node);
|
|
}
|
|
}
|
|
|
|
let target = type_param.syntax().text_range();
|
|
|
|
acc.add(
|
|
AssistId("replace_named_generic_with_impl", AssistKind::RefactorRewrite),
|
|
"Replace named generic with impl trait",
|
|
target,
|
|
|edit| {
|
|
let type_param = edit.make_mut(type_param);
|
|
let fn_ = edit.make_mut(fn_);
|
|
|
|
let path_types_to_replace = path_types_to_replace
|
|
.into_iter()
|
|
.map(|param| edit.make_mut(param))
|
|
.collect::<Vec<_>>();
|
|
|
|
// remove trait from generic param list
|
|
if let Some(generic_params) = fn_.generic_param_list() {
|
|
generic_params.remove_generic_param(ast::GenericParam::TypeParam(type_param));
|
|
if generic_params.generic_params().count() == 0 {
|
|
ted::remove(generic_params.syntax());
|
|
}
|
|
}
|
|
|
|
let new_bounds = impl_trait_type(type_bound_list);
|
|
for path_type in path_types_to_replace.iter().rev() {
|
|
ted::replace(path_type.syntax(), new_bounds.clone_for_update().syntax());
|
|
}
|
|
},
|
|
)
|
|
}
|
|
|
|
fn find_path_type(
|
|
sema: &Semantics<'_, RootDatabase>,
|
|
type_param_name: &Name,
|
|
param: &NameLike,
|
|
) -> Option<PathType> {
|
|
let path_type =
|
|
sema.ancestors_with_macros(param.syntax().clone()).find_map(ast::PathType::cast)?;
|
|
|
|
// Ignore any path types that look like `P::Assoc`
|
|
if path_type.path()?.as_single_name_ref()?.text() != type_param_name.text() {
|
|
return None;
|
|
}
|
|
|
|
let ancestors = sema.ancestors_with_macros(path_type.syntax().clone());
|
|
|
|
let mut in_generic_arg_list = false;
|
|
let mut is_associated_type = false;
|
|
|
|
// walking the ancestors checks them in a heuristic way until the `Fn` node is reached.
|
|
for ancestor in ancestors {
|
|
match_ast! {
|
|
match ancestor {
|
|
ast::PathSegment(ps) => {
|
|
match ps.kind()? {
|
|
ast::PathSegmentKind::Name(_name_ref) => (),
|
|
ast::PathSegmentKind::Type { .. } => return None,
|
|
_ => return None,
|
|
}
|
|
},
|
|
ast::GenericArgList(_) => {
|
|
in_generic_arg_list = true;
|
|
},
|
|
ast::AssocTypeArg(_) => {
|
|
is_associated_type = true;
|
|
},
|
|
ast::ImplTraitType(_) => {
|
|
if in_generic_arg_list && !is_associated_type {
|
|
return None;
|
|
}
|
|
},
|
|
ast::DynTraitType(_) => {
|
|
if !is_associated_type {
|
|
return None;
|
|
}
|
|
},
|
|
ast::Fn(_) => return Some(path_type),
|
|
_ => (),
|
|
}
|
|
}
|
|
}
|
|
|
|
None
|
|
}
|
|
|
|
/// Returns all usage references for the given type parameter definition.
|
|
fn find_usages(
|
|
sema: &Semantics<'_, RootDatabase>,
|
|
fn_: &ast::Fn,
|
|
type_param_def: Definition,
|
|
file_id: FileId,
|
|
) -> UsageSearchResult {
|
|
let file_range = FileRange { file_id, range: fn_.syntax().text_range() };
|
|
type_param_def.usages(sema).in_scope(&SearchScope::file_range(file_range)).all()
|
|
}
|
|
|
|
fn check_valid_usages(usages: &UsageSearchResult, param_list_range: TextRange) -> bool {
|
|
usages
|
|
.iter()
|
|
.flat_map(|(_, usage_refs)| usage_refs)
|
|
.all(|usage_ref| param_list_range.contains_range(usage_ref.range))
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
|
|
use crate::tests::{check_assist, check_assist_not_applicable};
|
|
|
|
#[test]
|
|
fn replace_generic_moves_into_function() {
|
|
check_assist(
|
|
replace_named_generic_with_impl,
|
|
r#"fn new<T$0: ToString>(input: T) -> Self {}"#,
|
|
r#"fn new(input: impl ToString) -> Self {}"#,
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn replace_generic_with_inner_associated_type() {
|
|
check_assist(
|
|
replace_named_generic_with_impl,
|
|
r#"fn new<P$0: AsRef<Path>>(input: P) -> Self {}"#,
|
|
r#"fn new(input: impl AsRef<Path>) -> Self {}"#,
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn replace_generic_trait_applies_to_all_matching_params() {
|
|
check_assist(
|
|
replace_named_generic_with_impl,
|
|
r#"fn new<T$0: ToString>(a: T, b: T) -> Self {}"#,
|
|
r#"fn new(a: impl ToString, b: impl ToString) -> Self {}"#,
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn replace_generic_trait_applies_to_generic_arguments_in_params() {
|
|
check_assist(
|
|
replace_named_generic_with_impl,
|
|
r#"
|
|
fn foo<P$0: Trait>(
|
|
_: P,
|
|
_: Option<P>,
|
|
_: Option<Option<P>>,
|
|
_: impl Iterator<Item = P>,
|
|
_: &dyn Iterator<Item = P>,
|
|
) {}
|
|
"#,
|
|
r#"
|
|
fn foo(
|
|
_: impl Trait,
|
|
_: Option<impl Trait>,
|
|
_: Option<Option<impl Trait>>,
|
|
_: impl Iterator<Item = impl Trait>,
|
|
_: &dyn Iterator<Item = impl Trait>,
|
|
) {}
|
|
"#,
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn replace_generic_not_applicable_when_one_param_type_is_invalid() {
|
|
check_assist_not_applicable(
|
|
replace_named_generic_with_impl,
|
|
r#"
|
|
fn foo<P$0: Trait>(
|
|
_: i32,
|
|
_: Option<P>,
|
|
_: Option<Option<P>>,
|
|
_: impl Iterator<Item = P>,
|
|
_: &dyn Iterator<Item = P>,
|
|
_: <P as Trait>::Assoc,
|
|
) {}
|
|
"#,
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn replace_generic_not_applicable_when_referenced_in_where_clause() {
|
|
check_assist_not_applicable(
|
|
replace_named_generic_with_impl,
|
|
r#"fn foo<P$0: Trait, I>() where I: FromRef<P> {}"#,
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn replace_generic_not_applicable_when_used_with_type_alias() {
|
|
check_assist_not_applicable(
|
|
replace_named_generic_with_impl,
|
|
r#"fn foo<P$0: Trait>(p: <P as Trait>::Assoc) {}"#,
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn replace_generic_not_applicable_when_used_as_argument_in_outer_trait_alias() {
|
|
check_assist_not_applicable(
|
|
replace_named_generic_with_impl,
|
|
r#"fn foo<P$0: Trait>(_: <() as OtherTrait<P>>::Assoc) {}"#,
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn replace_generic_not_applicable_with_inner_associated_type() {
|
|
check_assist_not_applicable(
|
|
replace_named_generic_with_impl,
|
|
r#"fn foo<P$0: Trait>(_: P::Assoc) {}"#,
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn replace_generic_not_applicable_when_passed_into_outer_impl_trait() {
|
|
check_assist_not_applicable(
|
|
replace_named_generic_with_impl,
|
|
r#"fn foo<P$0: Trait>(_: impl OtherTrait<P>) {}"#,
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn replace_generic_not_applicable_when_used_in_passed_function_parameter() {
|
|
check_assist_not_applicable(
|
|
replace_named_generic_with_impl,
|
|
r#"fn foo<P$0: Trait>(_: &dyn Fn(P)) {}"#,
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn replace_generic_with_multiple_generic_params() {
|
|
check_assist(
|
|
replace_named_generic_with_impl,
|
|
r#"fn new<P: AsRef<Path>, T$0: ToString>(t: T, p: P) -> Self {}"#,
|
|
r#"fn new<P: AsRef<Path>>(t: impl ToString, p: P) -> Self {}"#,
|
|
);
|
|
check_assist(
|
|
replace_named_generic_with_impl,
|
|
r#"fn new<T$0: ToString, P: AsRef<Path>>(t: T, p: P) -> Self {}"#,
|
|
r#"fn new<P: AsRef<Path>>(t: impl ToString, p: P) -> Self {}"#,
|
|
);
|
|
check_assist(
|
|
replace_named_generic_with_impl,
|
|
r#"fn new<A: Send, B$0: ToString, C: Debug>(a: A, b: B, c: C) -> Self {}"#,
|
|
r#"fn new<A: Send, C: Debug>(a: A, b: impl ToString, c: C) -> Self {}"#,
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn replace_generic_with_multiple_trait_bounds() {
|
|
check_assist(
|
|
replace_named_generic_with_impl,
|
|
r#"fn new<P$0: Send + Sync>(p: P) -> Self {}"#,
|
|
r#"fn new(p: impl Send + Sync) -> Self {}"#,
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn replace_generic_not_applicable_if_param_used_as_return_type() {
|
|
check_assist_not_applicable(
|
|
replace_named_generic_with_impl,
|
|
r#"fn new<P$0: Send + Sync>(p: P) -> P {}"#,
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn replace_generic_not_applicable_if_param_used_in_fn_body() {
|
|
check_assist_not_applicable(
|
|
replace_named_generic_with_impl,
|
|
r#"fn new<P$0: ToString>(p: P) { let x: &dyn P = &O; }"#,
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn replace_generic_ignores_another_function_with_same_param_type() {
|
|
check_assist(
|
|
replace_named_generic_with_impl,
|
|
r#"
|
|
fn new<P$0: Send + Sync>(p: P) {}
|
|
fn hello<P: Debug>(p: P) { println!("{:?}", p); }
|
|
"#,
|
|
r#"
|
|
fn new(p: impl Send + Sync) {}
|
|
fn hello<P: Debug>(p: P) { println!("{:?}", p); }
|
|
"#,
|
|
);
|
|
}
|
|
}
|