Make ReferenceConversion methods return ast types

Author: DropDemBits

crates/ide-assists/src/handlers/generate_function.rs

@@ -1033,7 +1033,7 @@ fn fn_arg_type(
         if ty.is_reference() || ty.is_mutable_reference() {
             let famous_defs = &FamousDefs(&ctx.sema, ctx.sema.scope(fn_arg.syntax())?.krate());
             convert_reference_type(ty.strip_references(), ctx.db(), famous_defs)
-                .map(|conversion| conversion.convert_type(ctx.db()))
+                .map(|conversion| conversion.convert_type(ctx.db()).to_string())
                 .or_else(|| ty.display_source_code(ctx.db(), target_module.into(), true).ok())
         } else {
             ty.display_source_code(ctx.db(), target_module.into(), true).ok()

crates/ide-assists/src/handlers/generate_getter_or_setter.rs

@@ -233,8 +233,8 @@ fn generate_getter_from_info(
                 .map(|conversion| {
                     cov_mark::hit!(convert_reference_type);
                     (
-                        conversion.convert_type(ctx.db()),
-                        conversion.getter(record_field_info.field_name.to_string()),
+                        conversion.convert_type(ctx.db()).to_string(),
+                        conversion.getter(record_field_info.field_name.to_string()).to_string(),
                     )
                 })
         })()

crates/ide-assists/src/utils.rs

@@ -718,8 +718,8 @@ enum ReferenceConversionType {
 }
 
 impl ReferenceConversion {
-    pub(crate) fn convert_type(&self, db: &dyn HirDatabase) -> String {
-        match self.conversion {
+    pub(crate) fn convert_type(&self, db: &dyn HirDatabase) -> ast::Type {
+        let ty = match self.conversion {
             ReferenceConversionType::Copy => self.ty.display(db).to_string(),
             ReferenceConversionType::AsRefStr => "&str".to_string(),
             ReferenceConversionType::AsRefSlice => {
@@ -745,21 +745,25 @@ impl ReferenceConversion {
                     type_arguments.next().unwrap().display(db).to_string();
                 format!("Result<&{first_type_argument_name}, &{second_type_argument_name}>")
             }
-        }
+        };
+
+        make::ty(&ty)
     }
 
-    pub(crate) fn getter(&self, field_name: String) -> String {
+    pub(crate) fn getter(&self, field_name: String) -> ast::Expr {
+        let expr = make::expr_field(make::ext::expr_self(), &field_name);
+
         match self.conversion {
-            ReferenceConversionType::Copy => format!("self.{field_name}"),
+            ReferenceConversionType::Copy => expr,
             ReferenceConversionType::AsRefStr
             | ReferenceConversionType::AsRefSlice
             | ReferenceConversionType::Dereferenced
             | ReferenceConversionType::Option
             | ReferenceConversionType::Result => {
                 if self.impls_deref {
-                    format!("&self.{field_name}")
+                    make::expr_ref(expr, false)
                 } else {
-                    format!("self.{field_name}.as_ref()")
+                    make::expr_method_call(expr, make::name_ref("as_ref"), make::arg_list([]))
                 }
             }
         }