4 use hir::{Module, ModuleDef, Name, Variant};
8 insert_use::{insert_use, ImportScope},
11 search::FileReference,
14 use rustc_hash::FxHashSet;
16 algo::{find_node_at_offset, SyntaxRewriter},
17 ast::{self, edit::IndentLevel, make, AstNode, NameOwner, VisibilityOwner},
18 SourceFile, SyntaxElement, SyntaxNode, T,
21 use crate::{AssistContext, AssistId, AssistKind, Assists};
23 // Assist: extract_struct_from_enum_variant
25 // Extracts a struct from enum variant.
28 // enum A { $0One(u32, u32) }
32 // struct One(pub u32, pub u32);
34 // enum A { One(One) }
36 pub(crate) fn extract_struct_from_enum_variant(
40 let variant = ctx.find_node_at_offset::<ast::Variant>()?;
41 let field_list = extract_field_list_if_applicable(&variant)?;
43 let variant_name = variant.name()?;
44 let variant_hir = ctx.sema.to_def(&variant)?;
45 if existing_definition(ctx.db(), &variant_name, &variant_hir) {
49 let enum_ast = variant.parent_enum();
50 let enum_hir = ctx.sema.to_def(&enum_ast)?;
51 let target = variant.syntax().text_range();
53 AssistId("extract_struct_from_enum_variant", AssistKind::RefactorRewrite),
54 "Extract struct from enum variant",
57 let variant_hir_name = variant_hir.name(ctx.db());
58 let enum_module_def = ModuleDef::from(enum_hir);
60 Definition::ModuleDef(ModuleDef::Variant(variant_hir)).usages(&ctx.sema).all();
62 let mut visited_modules_set = FxHashSet::default();
63 let current_module = enum_hir.module(ctx.db());
64 visited_modules_set.insert(current_module);
65 let mut def_rewriter = None;
66 for (file_id, references) in usages {
67 let mut rewriter = SyntaxRewriter::default();
68 let source_file = ctx.sema.parse(file_id);
69 for reference in references {
77 &mut visited_modules_set,
80 if file_id == ctx.frange.file_id {
81 def_rewriter = Some(rewriter);
84 builder.edit_file(file_id);
85 builder.rewrite(rewriter);
87 let mut rewriter = def_rewriter.unwrap_or_default();
88 update_variant(&mut rewriter, &variant);
94 &variant.parent_enum().syntax().clone().into(),
95 enum_ast.visibility(),
97 builder.edit_file(ctx.frange.file_id);
98 builder.rewrite(rewriter);
103 fn extract_field_list_if_applicable(
104 variant: &ast::Variant,
105 ) -> Option<Either<ast::RecordFieldList, ast::TupleFieldList>> {
106 match variant.kind() {
107 ast::StructKind::Record(field_list) if field_list.fields().next().is_some() => {
108 Some(Either::Left(field_list))
110 ast::StructKind::Tuple(field_list) if field_list.fields().count() > 1 => {
111 Some(Either::Right(field_list))
117 fn existing_definition(db: &RootDatabase, variant_name: &ast::Name, variant: &Variant) -> bool {
123 .filter(|(_, def)| match def {
124 // only check type-namespace
125 hir::ScopeDef::ModuleDef(def) => matches!(
129 | ModuleDef::Variant(_)
130 | ModuleDef::Trait(_)
131 | ModuleDef::TypeAlias(_)
132 | ModuleDef::BuiltinType(_)
136 .any(|(name, _)| name.to_string() == variant_name.to_string())
141 rewriter: &mut SyntaxRewriter,
142 scope_node: &SyntaxNode,
144 enum_module_def: &ModuleDef,
145 variant_hir_name: &Name,
148 let mod_path = module.find_use_path_prefixed(
150 enum_module_def.clone(),
151 ctx.config.insert_use.prefix_kind,
153 if let Some(mut mod_path) = mod_path {
154 mod_path.pop_segment();
155 mod_path.push_segment(variant_hir_name.clone());
156 let scope = ImportScope::find_insert_use_container(scope_node, &ctx.sema)?;
157 *rewriter += insert_use(&scope, mod_path_to_ast(&mod_path), ctx.config.insert_use);
162 fn extract_struct_def(
163 rewriter: &mut SyntaxRewriter,
165 variant_name: ast::Name,
166 field_list: &Either<ast::RecordFieldList, ast::TupleFieldList>,
167 start_offset: &SyntaxElement,
168 visibility: Option<ast::Visibility>,
170 let pub_vis = Some(make::visibility_pub());
171 let field_list = match field_list {
172 Either::Left(field_list) => {
173 make::record_field_list(field_list.fields().flat_map(|field| {
174 Some(make::record_field(pub_vis.clone(), field.name()?, field.ty()?))
178 Either::Right(field_list) => make::tuple_field_list(
181 .flat_map(|field| Some(make::tuple_field(pub_vis.clone(), field.ty()?))),
186 rewriter.insert_before(
188 make::struct_(visibility, variant_name, None, field_list).syntax(),
190 rewriter.insert_before(start_offset, &make::tokens::blank_line());
192 if let indent_level @ 1..=usize::MAX = IndentLevel::from_node(enum_.syntax()).0 as usize {
194 .insert_before(start_offset, &make::tokens::whitespace(&" ".repeat(4 * indent_level)));
199 fn update_variant(rewriter: &mut SyntaxRewriter, variant: &ast::Variant) -> Option<()> {
200 let name = variant.name()?;
201 let tuple_field = make::tuple_field(None, make::ty(name.text()));
202 let replacement = make::variant(
204 Some(ast::FieldList::TupleFieldList(make::tuple_field_list(iter::once(tuple_field)))),
206 rewriter.replace(variant.syntax(), replacement.syntax());
212 rewriter: &mut SyntaxRewriter,
213 reference: FileReference,
214 source_file: &SourceFile,
215 enum_module_def: &ModuleDef,
216 variant_hir_name: &Name,
217 visited_modules_set: &mut FxHashSet<Module>,
219 let offset = reference.range.start();
220 let (segment, expr) = if let Some(path_expr) =
221 find_node_at_offset::<ast::PathExpr>(source_file.syntax(), offset)
224 (path_expr.path()?.segment()?, path_expr.syntax().parent()?)
225 } else if let Some(record_expr) =
226 find_node_at_offset::<ast::RecordExpr>(source_file.syntax(), offset)
229 (record_expr.path()?.segment()?, record_expr.syntax().clone())
234 let module = ctx.sema.scope(&expr).module()?;
235 if !visited_modules_set.contains(&module) {
236 if insert_import(ctx, rewriter, &expr, &module, enum_module_def, variant_hir_name).is_some()
238 visited_modules_set.insert(module);
241 rewriter.insert_after(segment.syntax(), &make::token(T!['(']));
242 rewriter.insert_after(segment.syntax(), segment.syntax());
243 rewriter.insert_after(&expr, &make::token(T![')']));
249 use ide_db::helpers::FamousDefs;
251 use crate::tests::{check_assist, check_assist_not_applicable};
256 fn test_extract_struct_several_fields_tuple() {
258 extract_struct_from_enum_variant,
259 "enum A { $0One(u32, u32) }",
260 r#"struct One(pub u32, pub u32);
262 enum A { One(One) }"#,
267 fn test_extract_struct_several_fields_named() {
269 extract_struct_from_enum_variant,
270 "enum A { $0One { foo: u32, bar: u32 } }",
271 r#"struct One{ pub foo: u32, pub bar: u32 }
273 enum A { One(One) }"#,
278 fn test_extract_struct_one_field_named() {
280 extract_struct_from_enum_variant,
281 "enum A { $0One { foo: u32 } }",
282 r#"struct One{ pub foo: u32 }
284 enum A { One(One) }"#,
289 fn test_extract_enum_variant_name_value_namespace() {
291 extract_struct_from_enum_variant,
292 r#"const One: () = ();
293 enum A { $0One(u32, u32) }"#,
294 r#"const One: () = ();
295 struct One(pub u32, pub u32);
297 enum A { One(One) }"#,
302 fn test_extract_struct_pub_visibility() {
304 extract_struct_from_enum_variant,
305 "pub enum A { $0One(u32, u32) }",
306 r#"pub struct One(pub u32, pub u32);
308 pub enum A { One(One) }"#,
313 fn test_extract_struct_with_complex_imports() {
315 extract_struct_from_enum_variant,
318 let m = my_other_mod::MyEnum::MyField(1, 1);
321 pub mod my_other_mod {
323 let m = MyEnum::MyField(1, 1);
333 let m = my_mod::my_other_mod::MyEnum::MyField(1, 1);
335 r#"use my_mod::my_other_mod::MyField;
338 use self::my_other_mod::MyField;
341 let m = my_other_mod::MyEnum::MyField(MyField(1, 1));
344 pub mod my_other_mod {
346 let m = MyEnum::MyField(MyField(1, 1));
349 pub struct MyField(pub u8, pub u8);
358 let m = my_mod::my_other_mod::MyEnum::MyField(MyField(1, 1));
364 fn extract_record_fix_references() {
366 extract_struct_from_enum_variant,
369 $0V { i: i32, j: i32 }
373 let e = E::V { i: 9, j: 2 };
377 struct V{ pub i: i32, pub j: i32 }
384 let e = E::V(V { i: 9, j: 2 });
391 fn test_several_files() {
393 extract_struct_from_enum_variant,
409 struct V(pub i32, pub i32);
419 let e = E::V(V(9, 2));
426 fn test_several_files_record() {
428 extract_struct_from_enum_variant,
432 $0V { i: i32, j: i32 }
439 let e = E::V { i: 9, j: 2 };
444 struct V{ pub i: i32, pub j: i32 }
454 let e = E::V(V { i: 9, j: 2 });
461 fn test_extract_struct_record_nested_call_exp() {
463 extract_struct_from_enum_variant,
465 enum A { $0One { a: u32, b: u32 } }
470 let _ = B(A::One { a: 1, b: 2 });
474 struct One{ pub a: u32, pub b: u32 }
481 let _ = B(A::One(One { a: 1, b: 2 }));
487 fn check_not_applicable(ra_fixture: &str) {
489 format!("//- /main.rs crate:main deps:core\n{}\n{}", ra_fixture, FamousDefs::FIXTURE);
490 check_assist_not_applicable(extract_struct_from_enum_variant, &fixture)
494 fn test_extract_enum_not_applicable_for_element_with_no_fields() {
495 check_not_applicable("enum A { $0One }");
499 fn test_extract_enum_not_applicable_if_struct_exists() {
500 check_not_applicable(
502 enum A { $0One(u8, u32) }"#,
507 fn test_extract_not_applicable_one_field() {
508 check_not_applicable(r"enum A { $0One(u32) }");
512 fn test_extract_not_applicable_no_field_tuple() {
513 check_not_applicable(r"enum A { $0None() }");
517 fn test_extract_not_applicable_no_field_named() {
518 check_not_applicable(r"enum A { $0None {} }");