1 use ide_db::famous_defs::FamousDefs;
2 use stdx::{format_to, to_lower_snake_case};
3 use syntax::ast::{self, AstNode, HasName, HasVisibility};
6 utils::{convert_reference_type, find_impl_block_end, find_struct_impl, generate_impl_text},
7 AssistContext, AssistId, AssistKind, Assists, GroupLabel,
10 // Assist: generate_getter
12 // Generate a getter method.
15 // # //- minicore: as_ref
16 // # pub struct String;
17 // # impl AsRef<str> for String {
18 // # fn as_ref(&self) -> &str {
29 // # pub struct String;
30 // # impl AsRef<str> for String {
31 // # fn as_ref(&self) -> &str {
41 // fn $0name(&self) -> &str {
46 pub(crate) fn generate_getter(acc: &mut Assists, ctx: &AssistContext<'_>) -> Option<()> {
47 generate_getter_impl(acc, ctx, false)
50 // Assist: generate_getter_mut
52 // Generate a mut getter method.
66 // fn $0name_mut(&mut self) -> &mut String {
71 pub(crate) fn generate_getter_mut(acc: &mut Assists, ctx: &AssistContext<'_>) -> Option<()> {
72 generate_getter_impl(acc, ctx, true)
75 pub(crate) fn generate_getter_impl(
77 ctx: &AssistContext<'_>,
80 let strukt = ctx.find_node_at_offset::<ast::Struct>()?;
81 let field = ctx.find_node_at_offset::<ast::RecordField>()?;
83 let field_name = field.name()?;
84 let field_ty = field.ty()?;
86 // Return early if we've found an existing fn
87 let mut fn_name = to_lower_snake_case(&field_name.to_string());
89 format_to!(fn_name, "_mut");
91 let impl_def = find_struct_impl(ctx, &ast::Adt::Struct(strukt.clone()), fn_name.as_str())?;
93 let (id, label) = if mutable {
94 ("generate_getter_mut", "Generate a mut getter method")
96 ("generate_getter", "Generate a getter method")
98 let target = field.syntax().text_range();
100 &GroupLabel("Generate getter/setter".to_owned()),
101 AssistId(id, AssistKind::Generate),
105 let mut buf = String::with_capacity(512);
107 if impl_def.is_some() {
111 let vis = strukt.visibility().map_or(String::new(), |v| format!("{} ", v));
112 let (ty, body) = if mutable {
113 (format!("&mut {}", field_ty), format!("&mut self.{}", field_name))
116 let krate = ctx.sema.scope(field_ty.syntax())?.krate();
117 let famous_defs = &FamousDefs(&ctx.sema, krate);
119 .resolve_type(&field_ty)
120 .and_then(|ty| convert_reference_type(ty, ctx.db(), famous_defs))
122 cov_mark::hit!(convert_reference_type);
124 conversion.convert_type(ctx.db()),
125 conversion.getter(field_name.to_string()),
129 .unwrap_or_else(|| (format!("&{}", field_ty), format!("&self.{}", field_name)))
134 " {}fn {}(&{}self) -> {} {{
139 mutable.then(|| "mut ").unwrap_or_default(),
144 let start_offset = impl_def
145 .and_then(|impl_def| find_impl_block_end(impl_def, &mut buf))
147 buf = generate_impl_text(&ast::Adt::Struct(strukt.clone()), &buf);
148 strukt.syntax().text_range().end()
151 match ctx.config.snippet_cap {
153 builder.insert_snippet(cap, start_offset, buf.replacen("fn ", "fn $0", 1))
155 None => builder.insert(start_offset, buf),
163 use crate::tests::{check_assist, check_assist_not_applicable};
168 fn test_generate_getter_from_field() {
182 fn $0data(&self) -> &Data {
202 fn $0data_mut(&mut self) -> &mut Data {
211 fn test_generate_getter_already_implemented() {
212 check_assist_not_applicable(
220 fn data(&self) -> &Data {
227 check_assist_not_applicable(
235 fn data_mut(&mut self) -> &mut Data {
244 fn test_generate_getter_from_field_with_visibility_marker() {
248 pub(crate) struct Context {
253 pub(crate) struct Context {
258 pub(crate) fn $0data(&self) -> &Data {
267 fn test_multiple_generate_getter() {
277 fn data(&self) -> &Data {
289 fn data(&self) -> &Data {
293 fn $0count(&self) -> &usize {
302 fn test_not_a_special_case() {
303 cov_mark::check_count!(convert_reference_type, 0);
304 // Fake string which doesn't implement AsRef<str>
310 struct S { foo: $0String }
315 struct S { foo: String }
318 fn $0foo(&self) -> &String {
327 fn test_convert_reference_type() {
328 cov_mark::check_count!(convert_reference_type, 6);
335 struct S { foo: $0bool }
338 struct S { foo: bool }
341 fn $0foo(&self) -> bool {
354 impl AsRef<str> for String {
355 fn as_ref(&self) -> &str {
360 struct S { foo: $0String }
364 impl AsRef<str> for String {
365 fn as_ref(&self) -> &str {
370 struct S { foo: String }
373 fn $0foo(&self) -> &str {
387 pub struct Box<T>(T);
388 impl<T> AsRef<T> for Box<T> {
389 fn as_ref(&self) -> &T {
394 struct S { foo: $0Box<Sweets> }
399 pub struct Box<T>(T);
400 impl<T> AsRef<T> for Box<T> {
401 fn as_ref(&self) -> &T {
406 struct S { foo: Box<Sweets> }
409 fn $0foo(&self) -> &Sweets {
422 impl<T> AsRef<[T]> for Vec<T> {
423 fn as_ref(&self) -> &[T] {
428 struct S { foo: $0Vec<()> }
432 impl<T> AsRef<[T]> for Vec<T> {
433 fn as_ref(&self) -> &[T] {
438 struct S { foo: Vec<()> }
441 fn $0foo(&self) -> &[()] {
455 struct S { foo: $0Option<Failure> }
460 struct S { foo: Option<Failure> }
463 fn $0foo(&self) -> Option<&Failure> {
476 dat$0a: Result<bool, i32>,
481 data: Result<bool, i32>,
485 fn $0data(&self) -> Result<&bool, &i32> {