-use crate::{
- assist_context::{AssistContext, Assists},
- AssistId,
-};
use ide_db::helpers::FamousDefs;
+use itertools::Itertools;
+use stdx::format_to;
use syntax::{
- ast::{self, Impl, NameOwner},
+ ast::{self, HasGenericParams, HasName, HasTypeBounds, Impl},
AstNode,
};
-use test_utils::mark;
+
+use crate::{
+ assist_context::{AssistContext, Assists},
+ AssistId,
+};
// 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)?;
- let implements_default = is_default_implemented(ctx, &impl_)?;
- if implements_default {
+ 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 impl_def = ctx.sema.to_def(impl_)?;
- let ty = impl_def.target_ty(db);
+ 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_trait = FamousDefs(&ctx.sema, Some(krate)).core_default_Default()?;
- let implements_default = ty.impls_trait(db, default_trait, &[]);
- Some(implements_default)
+ 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)]
mod tests {
- use ide_db::helpers::FamousDefs;
-
use crate::tests::{check_assist, check_assist_not_applicable};
use super::*;
#[test]
fn generate_default() {
- check_pass(
+ check_assist(
+ generate_default_from_new,
r#"
+//- minicore: default
struct Example { _inner: () }
impl Example {
#[test]
fn generate_default2() {
- check_pass(
+ 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);
- check_not_applicable(
+ 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);
- check_not_applicable(
+ 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() {
- check_not_applicable(
+ 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: () }
}
#[test]
fn standalone_new_function() {
- check_not_applicable(
+ check_assist_not_applicable(
+ generate_default_from_new,
r#"
fn n$0ew() -> u32 {
0
#[test]
fn multiple_struct_blocks() {
- check_pass(
+ check_assist(
+ generate_default_from_new,
r#"
+//- minicore: default
struct Example { _inner: () }
struct Test { value: u32 }
#[test]
fn when_struct_is_after_impl() {
- check_pass(
+ check_assist(
+ generate_default_from_new,
r#"
+//- minicore: default
impl Example {
pub fn $0new() -> Self {
Self { _inner: () }
#[test]
fn struct_in_module() {
- check_pass(
+ check_assist(
+ generate_default_from_new,
r#"
+//- minicore: default
mod test {
struct Example { _inner: () }
#[test]
fn struct_in_module_with_default() {
- check_not_applicable(
+ cov_mark::check!(struct_in_module_with_default);
+ check_assist_not_applicable(
+ generate_default_from_new,
r#"
+//- minicore: default
mod test {
struct Example { _inner: () }
"#,
);
}
-
- fn check_pass(before: &str, after: &str) {
- let before = &format!("//- /main.rs crate:main deps:core{}{}", before, FamousDefs::FIXTURE);
- check_assist(generate_default_from_new, before, after);
- }
-
- fn check_not_applicable(before: &str) {
- let before = &format!("//- /main.rs crate:main deps:core{}{}", before, FamousDefs::FIXTURE);
- check_assist_not_applicable(generate_default_from_new, before);
- }
}
projects / rust.git / blobdiff