+use ide_db::helpers::FamousDefs;
+use itertools::Itertools;
+use stdx::format_to;
+use syntax::{
+ ast::{self, HasGenericParams, HasName, HasTypeBounds, Impl},
+ AstNode,
+};
+
use crate::{
assist_context::{AssistContext, Assists},
AssistId,
};
-use hir::TypeRef;
-use syntax::{
- ast::{self, Impl, NameOwner},
- AstNode,
-};
-use test_utils::mark;
// Assist: generate_default_from_new
//
let fn_name = fn_node.name()?;
if fn_name.text() != "new" {
- mark::hit!(other_function_than_new);
+ cov_mark::hit!(other_function_than_new);
return None;
}
if fn_node.param_list()?.params().next().is_some() {
- mark::hit!(new_function_with_parameters);
+ cov_mark::hit!(new_function_with_parameters);
return None;
}
let impl_ = fn_node.syntax().ancestors().into_iter().find_map(ast::Impl::cast)?;
- if is_default_implemented(ctx, &impl_).is_some() {
+ if is_default_implemented(ctx, &impl_) {
+ cov_mark::hit!(default_block_is_already_present);
+ cov_mark::hit!(struct_in_module_with_default);
return None;
}
"Generate a Default impl from a new fn",
insert_location,
move |builder| {
- let code = default_fn_node_for_new(impl_);
+ let default_code = " fn default() -> Self {
+ Self::new()
+ }";
+ let code = generate_trait_impl_text_from_impl(&impl_, "Default", default_code);
builder.insert(insert_location.end(), code);
},
)
}
-fn default_fn_node_for_new(impl_: Impl) -> String {
- format!(
- "
+fn generate_trait_impl_text_from_impl(impl_: &ast::Impl, trait_text: &str, code: &str) -> String {
+ let generic_params = impl_.generic_param_list();
+ let mut buf = String::with_capacity(code.len());
+ buf.push_str("\n\n");
+ buf.push_str("impl");
+
+ if let Some(generic_params) = &generic_params {
+ let lifetimes = generic_params.lifetime_params().map(|lt| format!("{}", lt.syntax()));
+ let type_params = generic_params.type_params().map(|type_param| {
+ let mut buf = String::new();
+ if let Some(it) = type_param.name() {
+ format_to!(buf, "{}", it.syntax());
+ }
+ if let Some(it) = type_param.colon_token() {
+ format_to!(buf, "{} ", it);
+ }
+ if let Some(it) = type_param.type_bound_list() {
+ format_to!(buf, "{}", it.syntax());
+ }
+ buf
+ });
+ let const_params = generic_params.const_params().map(|t| t.syntax().to_string());
+ let generics = lifetimes.chain(type_params).chain(const_params).format(", ");
+ format_to!(buf, "<{}>", generics);
+ }
+
+ buf.push(' ');
+ buf.push_str(trait_text);
+ buf.push_str(" for ");
+ buf.push_str(&impl_.self_ty().unwrap().syntax().text().to_string());
+
+ match impl_.where_clause() {
+ Some(where_clause) => {
+ format_to!(buf, "\n{}\n{{\n{}\n}}", where_clause, code);
+ }
+ None => {
+ format_to!(buf, " {{\n{}\n}}", code);
+ }
+ }
-impl Default for {} {{
- fn default() -> Self {{
- Self::new()
- }}
-}}",
- impl_.self_ty().unwrap().syntax().text()
- )
+ buf
}
-fn is_default_implemented(ctx: &AssistContext, impl_: &Impl) -> Option<bool> {
+fn is_default_implemented(ctx: &AssistContext, impl_: &Impl) -> bool {
let db = ctx.sema.db;
- let module = impl_.syntax().parent()?;
- let sema_scope = ctx.sema.scope(&module);
- let impls = sema_scope.module()?.impl_defs(db);
- let mut name = None;
- for i in impls {
- if let Some(TypeRef::Path(p)) = i.target_trait(db) {
- name = p.segments().iter().map(|s| s.name.to_string()).find(|n| n == "Default");
- }
- }
-
- name.map(|n| !n.is_empty())
+ let impl_ = ctx.sema.to_def(impl_);
+ let impl_def = match impl_ {
+ Some(value) => value,
+ None => return false,
+ };
+
+ let ty = impl_def.self_ty(db);
+ let krate = impl_def.module(db).krate();
+ let default = FamousDefs(&ctx.sema, Some(krate)).core_default_Default();
+ let default_trait = match default {
+ Some(value) => value,
+ None => return false,
+ };
+
+ ty.impls_trait(db, default_trait, &[])
}
#[cfg(test)]
check_assist(
generate_default_from_new,
r#"
+//- minicore: default
struct Example { _inner: () }
impl Example {
check_assist(
generate_default_from_new,
r#"
+//- minicore: default
struct Test { value: u32 }
impl Test {
);
}
+ #[test]
+ fn new_function_with_generic() {
+ check_assist(
+ generate_default_from_new,
+ r#"
+//- minicore: default
+pub struct Foo<T> {
+ _bar: *mut T,
+}
+
+impl<T> Foo<T> {
+ pub fn ne$0w() -> Self {
+ unimplemented!()
+ }
+}
+"#,
+ r#"
+pub struct Foo<T> {
+ _bar: *mut T,
+}
+
+impl<T> Foo<T> {
+ pub fn new() -> Self {
+ unimplemented!()
+ }
+}
+
+impl<T> Default for Foo<T> {
+ fn default() -> Self {
+ Self::new()
+ }
+}
+"#,
+ );
+ }
+
+ #[test]
+ fn new_function_with_generics() {
+ check_assist(
+ generate_default_from_new,
+ r#"
+//- minicore: default
+pub struct Foo<T, B> {
+ _tars: *mut T,
+ _bar: *mut B,
+}
+
+impl<T, B> Foo<T, B> {
+ pub fn ne$0w() -> Self {
+ unimplemented!()
+ }
+}
+"#,
+ r#"
+pub struct Foo<T, B> {
+ _tars: *mut T,
+ _bar: *mut B,
+}
+
+impl<T, B> Foo<T, B> {
+ pub fn new() -> Self {
+ unimplemented!()
+ }
+}
+
+impl<T, B> Default for Foo<T, B> {
+ fn default() -> Self {
+ Self::new()
+ }
+}
+"#,
+ );
+ }
+
+ #[test]
+ fn new_function_with_generic_and_bound() {
+ check_assist(
+ generate_default_from_new,
+ r#"
+//- minicore: default
+pub struct Foo<T> {
+ t: T,
+}
+
+impl<T: From<i32>> Foo<T> {
+ pub fn ne$0w() -> Self {
+ Foo { t: 0.into() }
+ }
+}
+"#,
+ r#"
+pub struct Foo<T> {
+ t: T,
+}
+
+impl<T: From<i32>> Foo<T> {
+ pub fn new() -> Self {
+ Foo { t: 0.into() }
+ }
+}
+
+impl<T: From<i32>> Default for Foo<T> {
+ fn default() -> Self {
+ Self::new()
+ }
+}
+"#,
+ );
+ }
+
+ #[test]
+ fn new_function_with_generics_and_bounds() {
+ check_assist(
+ generate_default_from_new,
+ r#"
+//- minicore: default
+pub struct Foo<T, B> {
+ _tars: T,
+ _bar: B,
+}
+
+impl<T: From<i32>, B: From<i64>> Foo<T, B> {
+ pub fn ne$0w() -> Self {
+ unimplemented!()
+ }
+}
+"#,
+ r#"
+pub struct Foo<T, B> {
+ _tars: T,
+ _bar: B,
+}
+
+impl<T: From<i32>, B: From<i64>> Foo<T, B> {
+ pub fn new() -> Self {
+ unimplemented!()
+ }
+}
+
+impl<T: From<i32>, B: From<i64>> Default for Foo<T, B> {
+ fn default() -> Self {
+ Self::new()
+ }
+}
+"#,
+ );
+ }
+
+ #[test]
+ fn new_function_with_generic_and_where() {
+ check_assist(
+ generate_default_from_new,
+ r#"
+//- minicore: default
+pub struct Foo<T> {
+ t: T,
+}
+
+impl<T: From<i32>> Foo<T>
+where
+ Option<T>: Debug
+{
+ pub fn ne$0w() -> Self {
+ Foo { t: 0.into() }
+ }
+}
+"#,
+ r#"
+pub struct Foo<T> {
+ t: T,
+}
+
+impl<T: From<i32>> Foo<T>
+where
+ Option<T>: Debug
+{
+ pub fn new() -> Self {
+ Foo { t: 0.into() }
+ }
+}
+
+impl<T: From<i32>> Default for Foo<T>
+where
+ Option<T>: Debug
+{
+ fn default() -> Self {
+ Self::new()
+ }
+}
+"#,
+ );
+ }
+
+ #[test]
+ fn new_function_with_generics_and_wheres() {
+ check_assist(
+ generate_default_from_new,
+ r#"
+//- minicore: default
+pub struct Foo<T, B> {
+ _tars: T,
+ _bar: B,
+}
+
+impl<T: From<i32>, B: From<i64>> Foo<T, B>
+where
+ Option<T>: Debug, Option<B>: Debug,
+{
+ pub fn ne$0w() -> Self {
+ unimplemented!()
+ }
+}
+"#,
+ r#"
+pub struct Foo<T, B> {
+ _tars: T,
+ _bar: B,
+}
+
+impl<T: From<i32>, B: From<i64>> Foo<T, B>
+where
+ Option<T>: Debug, Option<B>: Debug,
+{
+ pub fn new() -> Self {
+ unimplemented!()
+ }
+}
+
+impl<T: From<i32>, B: From<i64>> Default for Foo<T, B>
+where
+ Option<T>: Debug, Option<B>: Debug,
+{
+ fn default() -> Self {
+ Self::new()
+ }
+}
+"#,
+ );
+ }
+
#[test]
fn new_function_with_parameters() {
- mark::check!(new_function_with_parameters);
+ cov_mark::check!(new_function_with_parameters);
check_assist_not_applicable(
generate_default_from_new,
r#"
+//- minicore: default
struct Example { _inner: () }
impl Example {
#[test]
fn other_function_than_new() {
- mark::check!(other_function_than_new);
+ cov_mark::check!(other_function_than_new);
check_assist_not_applicable(
generate_default_from_new,
r#"
struct Example { _inner: () }
-impl Exmaple {
+impl Example {
pub fn a$0dd() -> Self {
Self { _inner: () }
}
#[test]
fn default_block_is_already_present() {
+ cov_mark::check!(default_block_is_already_present);
check_assist_not_applicable(
generate_default_from_new,
r#"
+//- minicore: default
struct Example { _inner: () }
-impl Exmaple {
+impl Example {
pub fn n$0ew() -> Self {
Self { _inner: () }
}
check_assist(
generate_default_from_new,
r#"
+//- minicore: default
struct Example { _inner: () }
struct Test { value: u32 }
check_assist(
generate_default_from_new,
r#"
+//- minicore: default
impl Example {
pub fn $0new() -> Self {
Self { _inner: () }
check_assist(
generate_default_from_new,
r#"
+//- minicore: default
mod test {
struct Example { _inner: () }
#[test]
fn struct_in_module_with_default() {
+ cov_mark::check!(struct_in_module_with_default);
check_assist_not_applicable(
generate_default_from_new,
r#"
+//- minicore: default
mod test {
struct Example { _inner: () }
projects / rust.git / blobdiff