Skip to content
This repository was archived by the owner on May 28, 2025. It is now read-only.

Commit 0f46f27

Browse files
DropDemBitsDropDemBits
committed
Migrate most of ide_assists::utils to format arg capture
1 parent d235373 commit 0f46f27

File tree

2 files changed

+30
-30
lines changed

2 files changed

+30
-30
lines changed

‎crates/ide-assists/src/utils.rs‎

Lines changed: 8 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -189,8 +189,8 @@ pub(crate) fn render_snippet(_cap: SnippetCap, node: &SyntaxNode, cursor: Cursor
189189
let mut placeholder = cursor.node().to_string();
190190
escape(&mut placeholder);
191191
let tab_stop = match cursor {
192-
Cursor::Replace(placeholder) => format!("${{0:{}}}", placeholder),
193-
Cursor::Before(placeholder) => format!("$0{}", placeholder),
192+
Cursor::Replace(placeholder) => format!("${{0:{placeholder}}}"),
193+
Cursor::Before(placeholder) => format!("$0{placeholder}"),
194194
};
195195

196196
let mut buf = node.to_string();
@@ -535,37 +535,37 @@ impl ReferenceConversion {
535535
ReferenceConversionType::AsRefSlice => {
536536
let type_argument_name =
537537
self.ty.type_arguments().next().unwrap().display(db).to_string();
538-
format!("&[{}]", type_argument_name)
538+
format!("&[{type_argument_name}]")
539539
}
540540
ReferenceConversionType::Dereferenced => {
541541
let type_argument_name =
542542
self.ty.type_arguments().next().unwrap().display(db).to_string();
543-
format!("&{}", type_argument_name)
543+
format!("&{type_argument_name}")
544544
}
545545
ReferenceConversionType::Option => {
546546
let type_argument_name =
547547
self.ty.type_arguments().next().unwrap().display(db).to_string();
548-
format!("Option<&{}>", type_argument_name)
548+
format!("Option<&{type_argument_name}>")
549549
}
550550
ReferenceConversionType::Result => {
551551
let mut type_arguments = self.ty.type_arguments();
552552
let first_type_argument_name =
553553
type_arguments.next().unwrap().display(db).to_string();
554554
let second_type_argument_name =
555555
type_arguments.next().unwrap().display(db).to_string();
556-
format!("Result<&{}, &{}>", first_type_argument_name, second_type_argument_name)
556+
format!("Result<&{first_type_argument_name}, &{second_type_argument_name}>")
557557
}
558558
}
559559
}
560560

561561
pub(crate) fn getter(&self, field_name: String) -> String {
562562
match self.conversion {
563-
ReferenceConversionType::Copy => format!("self.{}", field_name),
563+
ReferenceConversionType::Copy => format!("self.{field_name}"),
564564
ReferenceConversionType::AsRefStr
565565
| ReferenceConversionType::AsRefSlice
566566
| ReferenceConversionType::Dereferenced
567567
| ReferenceConversionType::Option
568-
| ReferenceConversionType::Result => format!("self.{}.as_ref()", field_name),
568+
| ReferenceConversionType::Result => format!("self.{field_name}.as_ref()"),
569569
}
570570
}
571571
}

‎crates/ide-assists/src/utils/gen_trait_fn_body.rs‎

Lines changed: 22 additions & 22 deletions
Original file line numberDiff line numberDiff line change
@@ -41,7 +41,7 @@ fn gen_clone_impl(adt: &ast::Adt, func: &ast::Fn) -> Option<()> {
4141
let mut arms = vec![];
4242
for variant in list.variants() {
4343
let name = variant.name()?;
44-
let variant_name = make::ext::path_from_idents(["Self", &format!("{}", name)])?;
44+
let variant_name = make::ext::path_from_idents(["Self", &format!("{name}")])?;
4545

4646
match variant.field_list() {
4747
// => match self { Self::Name { x } => Self::Name { x: x.clone() } }
@@ -70,7 +70,7 @@ fn gen_clone_impl(adt: &ast::Adt, func: &ast::Fn) -> Option<()> {
7070
let mut pats = vec![];
7171
let mut fields = vec![];
7272
for (i, _) in list.fields().enumerate() {
73-
let field_name = format!("arg{}", i);
73+
let field_name = format!("arg{i}");
7474
let pat = make::ident_pat(false, false, make::name(&field_name));
7575
pats.push(pat.into());
7676

@@ -118,7 +118,7 @@ fn gen_clone_impl(adt: &ast::Adt, func: &ast::Fn) -> Option<()> {
118118
let mut fields = vec![];
119119
for (i, _) in field_list.fields().enumerate() {
120120
let f_path = make::expr_path(make::ext::ident_path("self"));
121-
let target = make::expr_field(f_path, &format!("{}", i));
121+
let target = make::expr_field(f_path, &format!("{i}"));
122122
fields.push(gen_clone_call(target));
123123
}
124124
let struct_name = make::expr_path(make::ext::ident_path("Self"));
@@ -151,15 +151,15 @@ fn gen_debug_impl(adt: &ast::Adt, func: &ast::Fn) -> Option<()> {
151151
let mut arms = vec![];
152152
for variant in list.variants() {
153153
let name = variant.name()?;
154-
let variant_name = make::ext::path_from_idents(["Self", &format!("{}", name)])?;
154+
let variant_name = make::ext::path_from_idents(["Self", &format!("{name}")])?;
155155
let target = make::expr_path(make::ext::ident_path("f"));
156156

157157
match variant.field_list() {
158158
Some(ast::FieldList::RecordFieldList(list)) => {
159159
// => f.debug_struct(name)
160160
let target = make::expr_path(make::ext::ident_path("f"));
161161
let method = make::name_ref("debug_struct");
162-
let struct_name = format!("\"{}\"", name);
162+
let struct_name = format!("\"{name}\"");
163163
let args = make::arg_list(Some(make::expr_literal(&struct_name).into()));
164164
let mut expr = make::expr_method_call(target, method, args);
165165

@@ -173,8 +173,8 @@ fn gen_debug_impl(adt: &ast::Adt, func: &ast::Fn) -> Option<()> {
173173

174174
// => <expr>.field("field_name", field)
175175
let method_name = make::name_ref("field");
176-
let name = make::expr_literal(&(format!("\"{}\"", field_name))).into();
177-
let path = &format!("{}", field_name);
176+
let name = make::expr_literal(&(format!("\"{field_name}\""))).into();
177+
let path = &format!("{field_name}");
178178
let path = make::expr_path(make::ext::ident_path(path));
179179
let args = make::arg_list(vec![name, path]);
180180
expr = make::expr_method_call(expr, method_name, args);
@@ -192,13 +192,13 @@ fn gen_debug_impl(adt: &ast::Adt, func: &ast::Fn) -> Option<()> {
192192
// => f.debug_tuple(name)
193193
let target = make::expr_path(make::ext::ident_path("f"));
194194
let method = make::name_ref("debug_tuple");
195-
let struct_name = format!("\"{}\"", name);
195+
let struct_name = format!("\"{name}\"");
196196
let args = make::arg_list(Some(make::expr_literal(&struct_name).into()));
197197
let mut expr = make::expr_method_call(target, method, args);
198198

199199
let mut pats = vec![];
200200
for (i, _) in list.fields().enumerate() {
201-
let name = format!("arg{}", i);
201+
let name = format!("arg{i}");
202202

203203
// create a field pattern for use in `MyStruct(fields..)`
204204
let field_name = make::name(&name);
@@ -222,7 +222,7 @@ fn gen_debug_impl(adt: &ast::Adt, func: &ast::Fn) -> Option<()> {
222222
arms.push(make::match_arm(Some(pat.into()), None, expr));
223223
}
224224
None => {
225-
let fmt_string = make::expr_literal(&(format!("\"{}\"", name))).into();
225+
let fmt_string = make::expr_literal(&(format!("\"{name}\""))).into();
226226
let args = make::arg_list([target, fmt_string]);
227227
let macro_name = make::expr_path(make::ext::ident_path("write"));
228228
let macro_call = make::expr_macro_call(macro_name, args);
@@ -244,7 +244,7 @@ fn gen_debug_impl(adt: &ast::Adt, func: &ast::Fn) -> Option<()> {
244244
}
245245

246246
ast::Adt::Struct(strukt) => {
247-
let name = format!("\"{}\"", annotated_name);
247+
let name = format!("\"{annotated_name}\"");
248248
let args = make::arg_list(Some(make::expr_literal(&name).into()));
249249
let target = make::expr_path(make::ext::ident_path("f"));
250250

@@ -258,10 +258,10 @@ fn gen_debug_impl(adt: &ast::Adt, func: &ast::Fn) -> Option<()> {
258258
let mut expr = make::expr_method_call(target, method, args);
259259
for field in field_list.fields() {
260260
let name = field.name()?;
261-
let f_name = make::expr_literal(&(format!("\"{}\"", name))).into();
261+
let f_name = make::expr_literal(&(format!("\"{name}\""))).into();
262262
let f_path = make::expr_path(make::ext::ident_path("self"));
263263
let f_path = make::expr_ref(f_path, false);
264-
let f_path = make::expr_field(f_path, &format!("{}", name));
264+
let f_path = make::expr_field(f_path, &format!("{name}"));
265265
let args = make::arg_list([f_name, f_path]);
266266
expr = make::expr_method_call(expr, make::name_ref("field"), args);
267267
}
@@ -275,7 +275,7 @@ fn gen_debug_impl(adt: &ast::Adt, func: &ast::Fn) -> Option<()> {
275275
for (i, _) in field_list.fields().enumerate() {
276276
let f_path = make::expr_path(make::ext::ident_path("self"));
277277
let f_path = make::expr_ref(f_path, false);
278-
let f_path = make::expr_field(f_path, &format!("{}", i));
278+
let f_path = make::expr_field(f_path, &format!("{i}"));
279279
let method = make::name_ref("field");
280280
expr = make::expr_method_call(expr, method, make::arg_list(Some(f_path)));
281281
}
@@ -379,7 +379,7 @@ fn gen_hash_impl(adt: &ast::Adt, func: &ast::Fn) -> Option<()> {
379379
let mut stmts = vec![];
380380
for (i, _) in field_list.fields().enumerate() {
381381
let base = make::expr_path(make::ext::ident_path("self"));
382-
let target = make::expr_field(base, &format!("{}", i));
382+
let target = make::expr_field(base, &format!("{i}"));
383383
stmts.push(gen_hash_call(target));
384384
}
385385
make::block_expr(stmts, None).indent(ast::edit::IndentLevel(1))
@@ -453,10 +453,10 @@ fn gen_partial_eq(adt: &ast::Adt, func: &ast::Fn) -> Option<()> {
453453
for field in list.fields() {
454454
let field_name = field.name()?.to_string();
455455

456-
let l_name = &format!("l_{}", field_name);
456+
let l_name = &format!("l_{field_name}");
457457
l_fields.push(gen_record_pat_field(&field_name, l_name));
458458

459-
let r_name = &format!("r_{}", field_name);
459+
let r_name = &format!("r_{field_name}");
460460
r_fields.push(gen_record_pat_field(&field_name, r_name));
461461

462462
let lhs = make::expr_path(make::ext::ident_path(l_name));
@@ -484,12 +484,12 @@ fn gen_partial_eq(adt: &ast::Adt, func: &ast::Fn) -> Option<()> {
484484
let mut r_fields = vec![];
485485

486486
for (i, _) in list.fields().enumerate() {
487-
let field_name = format!("{}", i);
487+
let field_name = format!("{i}");
488488

489-
let l_name = format!("l{}", field_name);
489+
let l_name = format!("l{field_name}");
490490
l_fields.push(gen_tuple_field(&l_name));
491491

492-
let r_name = format!("r{}", field_name);
492+
let r_name = format!("r{field_name}");
493493
r_fields.push(gen_tuple_field(&r_name));
494494

495495
let lhs = make::expr_path(make::ext::ident_path(&l_name));
@@ -548,7 +548,7 @@ fn gen_partial_eq(adt: &ast::Adt, func: &ast::Fn) -> Option<()> {
548548
Some(ast::FieldList::TupleFieldList(field_list)) => {
549549
let mut expr = None;
550550
for (i, _) in field_list.fields().enumerate() {
551-
let idx = format!("{}", i);
551+
let idx = format!("{i}");
552552
let lhs = make::expr_path(make::ext::ident_path("self"));
553553
let lhs = make::expr_field(lhs, &idx);
554554
let rhs = make::expr_path(make::ext::ident_path("other"));
@@ -628,7 +628,7 @@ fn gen_partial_ord(adt: &ast::Adt, func: &ast::Fn) -> Option<()> {
628628
Some(ast::FieldList::TupleFieldList(field_list)) => {
629629
let mut exprs = vec![];
630630
for (i, _) in field_list.fields().enumerate() {
631-
let idx = format!("{}", i);
631+
let idx = format!("{i}");
632632
let lhs = make::expr_path(make::ext::ident_path("self"));
633633
let lhs = make::expr_field(lhs, &idx);
634634
let rhs = make::expr_path(make::ext::ident_path("other"));

0 commit comments

Comments
 (0)