-use hir::{AssocItem, HasSource, Impl};
+use hir::{known, HasSource, Name};
use syntax::{
ast::{self, NameOwner},
AstNode, TextRange,
// Generates is_empty implementation from the len method.
//
// ```
+// struct MyStruct { data: Vec<String> }
+//
// impl MyStruct {
// p$0ub fn len(&self) -> usize {
// self.data.len()
// ```
// ->
// ```
+// struct MyStruct { data: Vec<String> }
+//
// impl MyStruct {
// pub fn len(&self) -> usize {
// self.data.len()
return None;
}
- let impl_ = fn_node.syntax().ancestors().into_iter().find_map(ast::Impl::cast)?;
- let impl_def = ctx.sema.to_def(&impl_)?;
- if is_empty_implemented(ctx, &impl_def) {
+ let impl_ = fn_node.syntax().ancestors().find_map(ast::Impl::cast)?;
+ if get_impl_method(ctx, &impl_, &known::is_empty).is_some() {
cov_mark::hit!(is_empty_already_implemented);
return None;
}
- let range = get_text_range_of_len_function(ctx, &impl_def)?;
+ let range = get_text_range_of_len_function(ctx, &impl_)?;
acc.add(
AssistId("generate_is_empty_from_len", AssistKind::Generate),
"Generate a is_empty impl from a len function",
range,
|builder| {
- let code = get_is_empty_code();
+ let code = r#"
+
+ pub fn is_empty(&self) -> bool {
+ self.len() == 0
+ }"#
+ .to_string();
builder.insert(range.end(), code)
},
)
}
-fn get_function_from_impl(ctx: &AssistContext, impl_def: &Impl, name: &str) -> Option<AssocItem> {
+fn get_impl_method(
+ ctx: &AssistContext,
+ impl_: &ast::Impl,
+ fn_name: &Name,
+) -> Option<hir::Function> {
let db = ctx.sema.db;
- impl_def.items(db).into_iter().filter(|item| matches!(item, AssocItem::Function(_value))).find(
- |func| match func.name(db) {
- Some(fn_name) => fn_name.to_string() == name,
- None => false,
- },
- )
-}
+ let impl_def: hir::Impl = ctx.sema.to_def(impl_)?;
-fn is_empty_implemented(ctx: &AssistContext, impl_def: &Impl) -> bool {
- get_function_from_impl(ctx, impl_def, "is_empty").is_some()
+ let scope = ctx.sema.scope(impl_.syntax());
+ let krate = impl_def.module(db).krate();
+ let ty = impl_def.target_ty(db);
+ let traits_in_scope = scope.traits_in_scope();
+ ty.iterate_method_candidates(db, krate, &traits_in_scope, Some(fn_name), |_, func| Some(func))
}
-fn get_text_range_of_len_function(ctx: &AssistContext, impl_def: &Impl) -> Option<TextRange> {
+fn get_text_range_of_len_function(ctx: &AssistContext, impl_: &ast::Impl) -> Option<TextRange> {
let db = ctx.sema.db;
- let len_fn = get_function_from_impl(ctx, impl_def, "len")?;
-
- let mut range = None;
- if let AssocItem::Function(node) = len_fn {
- let node = node.source(db)?;
- range = Some(node.syntax().value.text_range());
- }
-
- range
-}
-
-fn get_is_empty_code() -> String {
- r#"
-
- pub fn is_empty(&self) -> bool {
- self.len() == 0
- }"#
- .to_string()
+ let func = get_impl_method(ctx, impl_, &known::len)?;
+ let node = func.source(db)?;
+ Some(node.syntax().value.text_range())
}
#[cfg(test)]
check_assist_not_applicable(
generate_is_empty_from_len,
r#"
+struct MyStruct { data: Vec<String> }
+
impl MyStruct {
p$0ub fn test(&self) -> usize {
self.data.len()
check_assist_not_applicable(
generate_is_empty_from_len,
r#"
+struct MyStruct { data: Vec<String> }
+
impl MyStruct {
p$0ub fn len(&self, _i: bool) -> usize {
self.data.len()
check_assist_not_applicable(
generate_is_empty_from_len,
r#"
+struct MyStruct { data: Vec<String> }
+
impl MyStruct {
p$0ub fn len(&self) -> usize {
self.data.len()
check_assist(
generate_is_empty_from_len,
r#"
+struct MyStruct { data: Vec<String> }
+
impl MyStruct {
p$0ub fn len(&self) -> usize {
self.data.len()
}
"#,
r#"
+struct MyStruct { data: Vec<String> }
+
impl MyStruct {
pub fn len(&self) -> usize {
self.data.len()
check_assist(
generate_is_empty_from_len,
r#"
+struct MyStruct { data: Vec<String> }
+
impl MyStruct {
pub fn new() -> Self {
Self { data: 0 }
}
pub fn work(&self) -> Option<usize> {
- // do some work
+
}
}
"#,
r#"
+struct MyStruct { data: Vec<String> }
+
impl MyStruct {
pub fn new() -> Self {
Self { data: 0 }
}
pub fn work(&self) -> Option<usize> {
- // do some work
+
+ }
+}
+"#,
+ );
+ }
+
+ #[test]
+ fn multiple_impls() {
+ check_assist_not_applicable(
+ generate_is_empty_from_len,
+ r#"
+struct MyStruct { data: Vec<String> }
+
+impl MyStruct {
+ p$0ub fn len(&self) -> usize {
+ self.data.len()
+ }
+}
+
+impl MyStruct {
+ pub fn is_empty(&self) -> bool {
+ self.len() == 0
}
}
"#,