rust-analyzer

diff --git a/crates/ide-assists/src/handlers/generate_getter_or_setter.rs b/crates/ide-assists/src/handlers/generate_getter_or_setter.rs
index 92a654743b..62ffd3d965 100644
--- a/crates/ide-assists/src/handlers/generate_getter_or_setter.rs
+++ b/crates/ide-assists/src/handlers/generate_getter_or_setter.rs

@@ -218,14 +218,14 @@ fn generate_getter_from_info(

ctx: &AssistContext<'_>,

info: &AssistInfo,

record_field_info: &RecordFieldInfo,

- syntax_factory: &SyntaxFactory,

+ make: &SyntaxFactory,

) -> ast::Fn {

let (ty, body) = if matches!(info.assist_type, AssistType::MutGet) {

- let self_expr = syntax_factory.expr_path(syntax_factory.ident_path("self"));

+ let self_expr = make.expr_path(make.ident_path("self"));

(

- syntax_factory.ty_ref(record_field_info.field_ty.clone(), true),

- syntax_factory.expr_ref(

- syntax_factory.expr_field(self_expr, &record_field_info.field_name.text()).into(),

+ make.ty_ref(record_field_info.field_ty.clone(), true),

+ make.expr_ref(

+ make.expr_field(self_expr, &record_field_info.field_name.text()).into(),

true,

)

@@ -239,21 +239,20 @@ fn generate_getter_from_info(

.map(|conversion| {

cov_mark::hit!(convert_reference_type);

(

- conversion.convert_type(ctx.db(), module),

- conversion.getter(record_field_info.field_name.to_string()),

+ conversion.convert_type_with_factory(make, ctx.db(), module),

+ conversion.getter(make, record_field_info.field_name.to_string()),

)

})

})()

.unwrap_or_else(|| {

(

- syntax_factory.ty_ref(record_field_info.field_ty.clone(), false),

- syntax_factory.expr_ref(

- syntax_factory

- .expr_field(

- syntax_factory.expr_path(syntax_factory.ident_path("self")),

- &record_field_info.field_name.text(),

- )

- .into(),

+ make.ty_ref(record_field_info.field_ty.clone(), false),

+ make.expr_ref(

+ make.expr_field(

+ make.expr_path(make.ident_path("self")),

+ &record_field_info.field_name.text(),

+ )

+ .into(),

false,

)

@@ -261,18 +260,18 @@ fn generate_getter_from_info(

};

let self_param = if matches!(info.assist_type, AssistType::MutGet) {

- syntax_factory.mut_self_param()

+ make.mut_self_param()

} else {

- syntax_factory.self_param()

+ make.self_param()

};

let strukt = &info.strukt;

- let fn_name = syntax_factory.name(&record_field_info.fn_name);

- let params = syntax_factory.param_list(Some(self_param), []);

- let ret_type = Some(syntax_factory.ret_type(ty));

- let body = syntax_factory.block_expr([], Some(body));

+ let fn_name = make.name(&record_field_info.fn_name);

+ let params = make.param_list(Some(self_param), []);

+ let ret_type = Some(make.ret_type(ty));

+ let body = make.block_expr([], Some(body));

- syntax_factory.fn_(

+ make.fn_(

None,

strukt.visibility(),

fn_name,

@@ -291,32 +290,29 @@ fn generate_getter_from_info(

fn generate_setter_from_info(

info: &AssistInfo,

record_field_info: &RecordFieldInfo,

- syntax_factory: &SyntaxFactory,

+ make: &SyntaxFactory,

) -> ast::Fn {

let strukt = &info.strukt;

let field_name = &record_field_info.fn_name;

- let fn_name = syntax_factory.name(&format!("set_{field_name}"));

+ let fn_name = make.name(&format!("set_{field_name}"));

let field_ty = &record_field_info.field_ty;

// Make the param list

// `(&mut self, $field_name: $field_ty)`

- let field_param = syntax_factory.param(

- syntax_factory.ident_pat(false, false, syntax_factory.name(field_name)).into(),

- field_ty.clone(),

- );

- let params = syntax_factory.param_list(Some(syntax_factory.mut_self_param()), [field_param]);

+ let field_param =

+ make.param(make.ident_pat(false, false, make.name(field_name)).into(), field_ty.clone());

+ let params = make.param_list(Some(make.mut_self_param()), [field_param]);

// Make the assignment body

// `self.$field_name = $field_name`

- let self_expr = syntax_factory.expr_path(syntax_factory.ident_path("self"));

- let lhs = syntax_factory.expr_field(self_expr, field_name);

- let rhs = syntax_factory.expr_path(syntax_factory.ident_path(field_name));

- let assign_stmt =

- syntax_factory.expr_stmt(syntax_factory.expr_assignment(lhs.into(), rhs).into());

- let body = syntax_factory.block_expr([assign_stmt.into()], None);

+ let self_expr = make.expr_path(make.ident_path("self"));

+ let lhs = make.expr_field(self_expr, field_name);

+ let rhs = make.expr_path(make.ident_path(field_name));

+ let assign_stmt = make.expr_stmt(make.expr_assignment(lhs.into(), rhs).into());

+ let body = make.block_expr([assign_stmt.into()], None);

// Make the setter fn

- syntax_factory.fn_(

+ make.fn_(

None,

strukt.visibility(),

fn_name,

diff --git a/crates/ide-assists/src/utils.rs b/crates/ide-assists/src/utils.rs
index 24e458e874..10057f8681 100644
--- a/crates/ide-assists/src/utils.rs
+++ b/crates/ide-assists/src/utils.rs

@@ -1035,8 +1035,8 @@ enum ReferenceConversionType {

}

impl<'db> ReferenceConversion<'db> {

- pub(crate) fn convert_type(&self, db: &'db dyn HirDatabase, module: hir::Module) -> ast::Type {

- let ty = match self.conversion {

+ fn type_to_string(&self, db: &'db dyn HirDatabase, module: hir::Module) -> String {

+ match self.conversion {

ReferenceConversionType::Copy => self

.ty

.display_source_code(db, module.into(), true)

@@ -1086,25 +1086,38 @@ impl<'db> ReferenceConversion<'db> {

.unwrap_or_else(|_| "_".to_owned());

format!("Result<&{first_type_argument_name}, &{second_type_argument_name}>")

}

- };

+ }

+ pub(crate) fn convert_type(&self, db: &'db dyn HirDatabase, module: hir::Module) -> ast::Type {

+ let ty = self.type_to_string(db, module);

make::ty(&ty)

}

- pub(crate) fn getter(&self, field_name: String) -> ast::Expr {

- let expr = make::expr_field(make::ext::expr_self(), &field_name);

+ pub(crate) fn convert_type_with_factory(

+ &self,

+ make: &SyntaxFactory,

+ db: &'db dyn HirDatabase,

+ module: hir::Module,

+ ) -> ast::Type {

+ let ty = self.type_to_string(db, module);

+ make.ty(&ty)

+ }

+ pub(crate) fn getter(&self, make: &SyntaxFactory, field_name: String) -> ast::Expr {

+ let expr = make.expr_field(make.expr_self(), &field_name);

match self.conversion {

- ReferenceConversionType::Copy => expr,

+ ReferenceConversionType::Copy => expr.into(),

ReferenceConversionType::AsRefStr

| ReferenceConversionType::AsRefSlice

| ReferenceConversionType::Dereferenced

| ReferenceConversionType::Option

| ReferenceConversionType::Result => {

if self.impls_deref {

- make::expr_ref(expr, false)

+ make.expr_ref(expr.into(), false)

} else {

- make::expr_method_call(expr, make::name_ref("as_ref"), make::arg_list([]))

+ make.expr_method_call(expr.into(), make.name_ref("as_ref"), make.arg_list([]))

.into()

}

diff --git a/crates/syntax/src/ast/syntax_factory/constructors.rs b/crates/syntax/src/ast/syntax_factory/constructors.rs
index fa81dfad1f..44114a7802 100644
--- a/crates/syntax/src/ast/syntax_factory/constructors.rs
+++ b/crates/syntax/src/ast/syntax_factory/constructors.rs

@@ -29,6 +29,10 @@ impl SyntaxFactory {

make::ext::expr_todo().clone_for_update()

}

+ pub fn expr_self(&self) -> ast::Expr {

+ make::ext::expr_self().clone_for_update()

+ }

pub fn lifetime(&self, text: &str) -> ast::Lifetime {

make::lifetime(text).clone_for_update()

}