feat: extract_struct_from_function_signature

fixed compilation all most done replace replacing ted

Author: mendelsshop

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

@@ -19,7 +19,7 @@ use syntax::{
     AstNode, Edition, NodeOrToken, SyntaxElement, SyntaxKind, SyntaxNode, T,
     algo::find_node_at_range,
     ast::{
-        self, HasArgList, HasGenericParams, HasName, HasVisibility,
+        self, HasArgList, HasAttrs, HasGenericParams, HasName, HasVisibility,
         edit::{AstNodeEdit, IndentLevel},
         make,
         syntax_factory::SyntaxFactory,
@@ -38,7 +38,7 @@ use crate::{AssistContext, Assists};
 // ```
 // ->
 // ```
-// struct FooStruct{ bar: u32, baz: u32 }
+// struct FooStruct { bar: u32, baz: u32 }
 //
 // fn foo(FooStruct { bar, baz, .. }: FooStruct) { ... }
 // ```
@@ -158,7 +158,6 @@ pub(crate) fn extract_struct_from_function_signature(
             let field_list = if let Some((target_scope, source_scope)) =
                 ctx.sema.scope(func.syntax()).zip(ctx.sema.scope(param_list.syntax()))
             {
-                let field_list = field_list.reset_indent();
                 let field_list =
                     PathTransform::generic_transformation(&target_scope, &source_scope)
                         .apply(field_list.syntax());
@@ -171,9 +170,9 @@ pub(crate) fn extract_struct_from_function_signature(
             } else {
                 field_list
             };
-            field_list.fields().filter_map(|f|f.ty()).try_for_each(|t|generate_new_lifetimes(&mut  editor, &t, &mut generics));
+            field_list.fields().filter_map(|f|f.ty()).try_for_each(|t|generate_new_lifetimes(builder, &t, &mut generics, ctx.vfs_file_id()));
             tracing::info!("extract_struct_from_function_signature: collecting fields");
-            let def = create_struct_def(& make, name.clone(), &func, &used_param_list, &field_list, generics);
+            let def = create_struct_def( builder, name.clone(), &func, &used_param_list, &field_list, generics, ctx.vfs_file_id());
             tracing::info!("extract_struct_from_function_signature: creating struct");
             let def = def.indent(indent);
             editor.insert_all(
@@ -272,49 +271,47 @@ fn pat_to_name(pat: ast::Pat) -> Option<ast::Name> {
     }
 }
 fn create_struct_def(
-    editor: &SyntaxFactory,
+    builder: &mut SourceChangeBuilder,
     name: ast::Name,
     func: &ast::Fn,
     param_ast: &[ast::Param],
     field_list: &ast::RecordFieldList,
     generics: Option<ast::GenericParamList>,
+    _file_id: FileId,
 ) -> ast::Struct {
     let fn_vis = func.visibility();
 
     // if we do not expleictly copy over comments/attribures they just get lost
     // TODO: what about comments/attributes in between parameters
-    // param_ast.iter().zip(field_list.fields()).for_each(|(param, field)| {
-    // editor.attr_inner(meta)
-    // let elements = take_all_comments(param.clone());
-    // editor.insert_all(Position::first_child_of(field.syntax()), elements);
-    // editor.insert_all(
-    //     Position::first_child_of(field.syntax()),
-    //     param
-    //         .attrs()
-    //         .flat_map(|it| [it.syntax().clone().into(), make::tokens::single_newline().into()])
-    //         .collect(),
-    // );
-    // });
+    param_ast.iter().zip(field_list.fields()).for_each(|(param, field)| {
+        let mut editor = builder.make_editor(field.syntax());
+        let elements = take_all_comments(param.clone());
+        editor.insert_all(Position::first_child_of(field.syntax()), elements);
+        editor.insert_all(
+            Position::first_child_of(field.syntax()),
+            param
+                .attrs()
+                .flat_map(|it| [it.syntax().clone().into(), make::tokens::single_newline().into()])
+                .collect(),
+        );
+        // this panics
+        // builder.add_file_edits(file_id, editor);
+    });
     let field_list = field_list.indent(IndentLevel::single());
 
     make::struct_(fn_vis, name, generics, field_list.into()).clone_for_update()
 }
-// Note: this also detaches whitespace after comments,
-// since `SyntaxNode::splice_children` (and by extension `ted::insert_all_raw`)
-// detaches nodes. If we only took the comments, we'd leave behind the old whitespace.
 fn take_all_comments(node: impl ast::AstNode) -> Vec<SyntaxElement> {
     let mut remove_next_ws = false;
     node.syntax()
         .children_with_tokens()
         .filter_map(move |child| match child.kind() {
             SyntaxKind::COMMENT => {
                 remove_next_ws = true;
-                child.detach();
                 Some(child)
             }
             SyntaxKind::WHITESPACE if remove_next_ws => {
                 remove_next_ws = false;
-                child.detach();
                 Some(make::tokens::single_newline().into())
             }
             _ => {
@@ -367,30 +364,38 @@ fn contains_impl_trait(ty: &ast::Type) -> bool {
     ty.syntax().descendants().any(|ty| ty.kind() == ast::ImplTraitType::kind())
 }
 fn generate_new_lifetimes(
-    editor: &mut SyntaxEditor,
+    builder: &mut SourceChangeBuilder,
     ty: &ast::Type,
     existing_type_param_list: &mut Option<ast::GenericParamList>,
+    _file_id: FileId,
 ) -> Option<()> {
     for token in ty.syntax().descendants() {
         // we do not have to worry about for<'a> because we are only looking at '_ or &Type
         // if you have an unbound lifetime thats on you
         if let Some(lt) = ast::Lifetime::cast(token.clone())
             && lt.text() == "'_"
         {
+            let mut editor = builder.make_editor(lt.syntax());
             let new_lt = generate_unique_lifetime_param_name(existing_type_param_list)?;
+            editor.replace(lt.syntax(), new_lt.syntax());
             existing_type_param_list
                 .get_or_insert(make::generic_param_list(std::iter::empty()).clone_for_update())
+                // TODO: used TED
                 .add_generic_param(make::lifetime_param(new_lt.clone()).clone_for_update().into());
-
-            // editor.replace(lt.syntax(), new_lt.clone_for_update().syntax());
+            // this panics
+            // builder.add_file_edits(file_id, editor);
         } else if let Some(r) = ast::RefType::cast(token.clone())
             && r.lifetime().is_none()
         {
+            let mut editor = builder.make_editor(r.syntax());
             let new_lt = generate_unique_lifetime_param_name(existing_type_param_list)?;
+            editor.insert(Position::after(r.amp_token()?), new_lt.syntax());
             existing_type_param_list
                 .get_or_insert(make::generic_param_list(std::iter::empty()).clone_for_update())
+                // TODO: used TED
                 .add_generic_param(make::lifetime_param(new_lt.clone()).clone_for_update().into());
-            // editor.insert(Position::after(r.amp_token()?), new_lt.clone_for_update().syntax());
+            // this panics
+            // builder.add_file_edits(file_id, editor);
         }
         // TODO: nominal types that have only lifetimes
         // struct Bar<'a, 'b> { f: &'a &'b i32 }
@@ -488,7 +493,7 @@ fn process_references(
                     ctx.sema.db,
                     *function_module_def,
                     ctx.config.insert_use.prefix_kind,
-                    ctx.config.import_path_config(),
+                    ctx.config.find_path_confg(ctx.sema.is_nightly(module.krate())),
                 );
                 if let Some(mut mod_path) = mod_path {
                     mod_path.pop_segment();
@@ -532,7 +537,6 @@ fn apply_references(
     name: ast::Name,
     file_id: impl Into<FileId>,
 ) -> Option<()> {
-    let make = SyntaxFactory::with_mappings();
     let mut editor = builder.make_editor(call.syntax());
     if let Some((scope, path)) = import {
         let scope = builder.make_import_scope_mut(scope);
@@ -642,7 +646,7 @@ fn one($0x: u8, y: u32) {}
 fn foo($0bar: i32$0, baz: i32) {}
 "#,
             r#"
-struct FooStruct{ bar: i32 }
+struct FooStruct { bar: i32 }
 
 fn foo(FooStruct { bar, .. }: FooStruct, baz: i32) {}
 "#,
@@ -656,7 +660,7 @@ fn foo(FooStruct { bar, .. }: FooStruct, baz: i32) {}
 fn foo($0bar: i32, baz: i32$0) {}
 "#,
             r#"
-struct FooStruct{ bar: i32, baz: i32 }
+struct FooStruct { bar: i32, baz: i32 }
 
 fn foo(FooStruct { bar, baz, .. }: FooStruct) {}
 "#,
@@ -674,7 +678,7 @@ fn main() {
 }
 "#,
             r#"
-struct FooStruct{ bar: i32, baz: i32 }
+struct FooStruct { bar: i32, baz: i32 }
 
 fn foo(FooStruct { bar, baz, .. }: FooStruct) {}
 
@@ -705,15 +709,15 @@ mod b {
 "#,
             r#"
 mod a {
-    pub struct FooStruct{ pub bar: i32 }
+    pub struct FooStruct { pub bar: i32 }
 
     pub fn foo(FooStruct { bar, .. }: FooStruct, baz: i32) {
         foo(FooStruct { bar: 1 }, 2)
     }
 }
 
 mod b {
-    use crate::a::{foo, FooStruct};
+    use crate::a::{FooStruct, foo};
 
     fn main() {
         foo(FooStruct { bar: 1 }, 2)
@@ -734,7 +738,7 @@ mod b {
     }
     "#,
             r#"
-    struct FooStruct{ bar: i32 }
+    struct FooStruct { bar: i32 }
 
     fn foo(FooStruct { bar, .. }: FooStruct, baz: i32) {}
 
@@ -753,7 +757,7 @@ mod b {
 fn foo<'a, A>($0bar: &'a A$0, baz: i32) {}
 "#,
             r#"
-struct FooStruct<'a, A>{ bar: &'a A }
+struct FooStruct<'a, A> { bar: &'a A }
 
 fn foo<'a, A>(FooStruct { bar, .. }: FooStruct<'a, A>, baz: i32) {}
 "#,
@@ -769,7 +773,7 @@ fn foo<'a, A>($0bar: &'a A$0, baz: i32) {
 }
 "#,
             r#"
-struct FooStruct<'a, A>{ bar: &'a A }
+struct FooStruct<'a, A> { bar: &'a A }
 
 fn foo<'a, A>(FooStruct { bar, .. }: FooStruct<'a, A>, baz: i32) {
     foo(FooStruct { bar: 1 }, 2)
@@ -786,7 +790,7 @@ fn foo<'a, A>(FooStruct { bar, .. }: FooStruct<'a, A>, baz: i32) {
 fn foo($0bar: &'_ i32$0, baz: i32) {}
 "#,
             r#"
-struct FooStruct<'a>{ bar: &'a i32 }
+struct FooStruct<'a> { bar: &'a i32 }
 
 fn foo(FooStruct { bar, .. }: FooStruct<'_>, baz: i32) {}
 "#,
@@ -801,7 +805,7 @@ fn foo(FooStruct { bar, .. }: FooStruct<'_>, baz: i32) {}
 fn foo($0bar: &i32$0, baz: i32) {}
 "#,
             r#"
-struct FooStruct<'a>{ bar: &'a i32 }
+struct FooStruct<'a> { bar: &'a i32 }
 
 fn foo(FooStruct { bar, .. }: FooStruct<'_>, baz: i32) {}
 "#,
@@ -815,7 +819,7 @@ fn foo(FooStruct { bar, .. }: FooStruct<'_>, baz: i32) {}
 fn foo<'a>($0bar: &'_ &'a i32$0, baz: i32) {}
 "#,
             r#"
-struct FooStruct<'a, 'b>{ bar: &'b &'a i32 }
+struct FooStruct<'a, 'b> { bar: &'b &'a i32 }
 
 fn foo<'a>(FooStruct { bar, .. }: FooStruct<'a, '_>, baz: i32) {}
 "#,
@@ -833,7 +837,7 @@ fn foo<'a>($0bar: &'_ &'a i32$0, baz: i32) {
 }
 "#,
             r#"
-struct FooStruct<'a, 'b>{ bar: &'b &'a i32 }
+struct FooStruct<'a, 'b> { bar: &'b &'a i32 }
 
 fn foo<'a>(FooStruct { bar, .. }: FooStruct<'a, '_>, baz: i32) {
     foo(FooStruct { bar: bar }, baz)
@@ -864,7 +868,7 @@ fn bar() {
 "#,
             r#"
 struct Foo
-struct FooStruct{ j: i32, i: i32 }
+struct FooStruct { j: i32, i: i32 }
 
 impl Foo {
     fn foo(&self, FooStruct { j, i, .. }: FooStruct, z:i32) {  }
@@ -895,7 +899,7 @@ fn bar() {
 "#,
             r#"
 struct Foo
-struct FooStruct{ j: i32, i: i32 }
+struct FooStruct { j: i32, i: i32 }
 
 impl Foo {
     fn foo(&self, FooStruct { j, i, .. }: FooStruct, z:i32) {  }
@@ -922,7 +926,7 @@ fn foo(
 ) { }
 "#,
             r#"
-struct FooStruct{ #[foo]
+struct FooStruct { #[foo]
 // gag
 f: i32 }