fixes: ide-assists, generate_new indent loses

Author: A4-Tacks

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

@@ -128,25 +128,39 @@ pub(crate) fn generate_new(acc: &mut Assists, ctx: &AssistContext<'_>) -> Option
         }
 
         // Get the mutable version of the impl to modify
-        let impl_def = if let Some(impl_def) = impl_def {
-            builder.make_mut(impl_def)
+        let (post_indent, impl_def) = if let Some(impl_def) = impl_def {
+            fn_.indent(impl_def.indent_level());
+            (None, builder.make_mut(impl_def))
         } else {
             // Generate a new impl to add the method to
             let impl_def = generate_impl(&ast::Adt::Struct(strukt.clone()));
+            let indent_level = strukt.indent_level();
 
             // Insert it after the adt
             let strukt = builder.make_mut(strukt.clone());
 
             ted::insert_all_raw(
                 ted::Position::after(strukt.syntax()),
-                vec![make::tokens::blank_line().into(), impl_def.syntax().clone().into()],
+                if indent_level.is_zero() {
+                    vec![make::tokens::blank_line().into(), impl_def.syntax().clone().into()]
+                } else {
+                    vec![
+                        make::tokens::blank_line().into(),
+                        make::tokens::whitespace(&indent_level.to_string()).into(),
+                        impl_def.syntax().clone().into(),
+                    ]
+                },
             );
 
-            impl_def
+            (Some(indent_level), impl_def)
         };
 
         // Add the `new` method at the start of the impl
         impl_def.get_or_create_assoc_item_list().add_item_at_start(fn_.into());
+
+        if let Some(indent_level) = post_indent {
+            impl_def.indent(indent_level);
+        }
     })
 }
 
@@ -425,6 +439,135 @@ impl Foo {
         );
     }
 
+    #[test]
+    fn non_zero_indent() {
+        check_assist(
+            generate_new,
+            r#"
+mod foo {
+    struct $0Foo {}
+}
+"#,
+            r#"
+mod foo {
+    struct Foo {}
+
+    impl Foo {
+        fn $0new() -> Self {
+            Self {  }
+        }
+    }
+}
+"#,
+        );
+        check_assist(
+            generate_new,
+            r#"
+mod foo {
+    mod bar {
+        struct $0Foo {}
+    }
+}
+"#,
+            r#"
+mod foo {
+    mod bar {
+        struct Foo {}
+
+        impl Foo {
+            fn $0new() -> Self {
+                Self {  }
+            }
+        }
+    }
+}
+"#,
+        );
+        check_assist(
+            generate_new,
+            r#"
+mod foo {
+    struct $0Foo {}
+
+    impl Foo {
+        fn some() {}
+    }
+}
+"#,
+            r#"
+mod foo {
+    struct Foo {}
+
+    impl Foo {
+        fn $0new() -> Self {
+            Self {  }
+        }
+
+        fn some() {}
+    }
+}
+"#,
+        );
+        check_assist(
+            generate_new,
+            r#"
+mod foo {
+    mod bar {
+        struct $0Foo {}
+
+        impl Foo {
+            fn some() {}
+        }
+    }
+}
+"#,
+            r#"
+mod foo {
+    mod bar {
+        struct Foo {}
+
+        impl Foo {
+            fn $0new() -> Self {
+                Self {  }
+            }
+
+            fn some() {}
+        }
+    }
+}
+"#,
+        );
+        check_assist(
+            generate_new,
+            r#"
+mod foo {
+    mod bar {
+struct $0Foo {}
+
+        impl Foo {
+            fn some() {}
+        }
+    }
+}
+"#,
+            r#"
+mod foo {
+    mod bar {
+struct Foo {}
+
+        impl Foo {
+            fn $0new() -> Self {
+                Self {  }
+            }
+
+            fn some() {}
+        }
+    }
+}
+"#,
+        );
+    }
+
     #[test]
     fn check_visibility_of_new_fn_based_on_struct() {
         check_assist(