Add ide-assist: extract_struct_from_function_signature

[mendelsshop]

When you select the signature of a function, you should have the ability to extract all or part of the function's parameters to a struct.

fn foo(bar: u32, baz: u32) { ... }

->

struct FooStruct {
     bar: u32,
     baz: u32,
}

fn foo(FooStruct) { ... }

Still very much a work in progress.

Closes: #20331

[mendelsshop]

I have a few design decisions that I do not know what I should do about:

• Functions support anonymous lifetimes, but structs do not so I should generate a new lifetime for every anonymous lifetime I see?

• Should a self parameter be extracted to the struct? What if the self parameter is fully selected?

• When I replace the signature in the original function, I could either 1) destructure the struct in the signature or 2) go around the whole function, updating all the uses.

fn foo(mut i: i32, j: i32) {
    i = j
}

->
1)

struct FooStruct{ i: i32, j: i32 }

fn foo(FooStruct { mut i, j }: FooStruct) {
    i = j
}

or 2)

struct FooStruct{ i: i32, j: i32 }

fn foo(mut foo_struct FooStruct) {
    foo_struct.i = foo_struct.j
}

• I would like there to be a way to just select a certain part of the signature and only extract that part to a new struct. If one character is selected, I want to assume that the user wants the whole function signature extracted to a struct, would that be a good way to differentiate whether to extract the whole signature or only a part of it?

• I am also not planning on supporting destructred patterns like:

fn foo((a, b): (i32, i32)) {}

[mendelsshop]

Also, I think CI is failing because the slow tests need to be updated.
I could not figure out how to update them.

[ChayimFriedman2]

• Functions support anonymous lifetimes, but structs do not so I should generate a new lifetime for every anonymous lifetime I see?

Lifetime support in r-a is very incomplete. Ideally I think we'd generate one lifetime for each invariant lifetime, and another one for all the covariant. We can't do it now so I think the best will be to always generate a single lifetime.

• When I replace the signature in the original function, I could either 1) destructure the struct in the signature or 2) go around the whole function, updating all the uses.

Assists should focus on one change. Therefore, I think we should destructure the parameter, and have another assist to convert to dot access.

Although... Destructuring in parameters isn't that common in idiomatic Rust, so I'm not sure. @rust-lang/rust-analyzer thoughts?

• I would like there to be a way to just select a certain part of the signature and only extract that part to a new struct. If one character is selected, I want to assume that the user wants the whole function signature extracted to a struct, would that be a good way to differentiate whether to extract the whole signature or only a part of it?

I think the assist should only be enabled when there is a selection, not on empty selection, that's too much clutter. This way you also don't have to fix the slow tests.

• I am also not planning on supporting destructred patterns like:

Feel free. This can always be added later if desired.

• Should a self parameter be extracted to the struct? What if the self parameter is fully selected?

Given what I said about selection, I think it should be treated like any other parameter, i.e. put it only if it's selected.

[mendelsshop]

What should I do about impl trait, my assumption is that just don't provide the assist then.

Also, when the struct has generics, the way I am doing it now only the function signature fully specifies all the generics while uses, rely on inference from the caller.

fn foo<'a>($0bar: &'_ &'a i32$0, baz: i32) {
    foo(bar, baz)
}

->

struct FooStruct<'a, 'b>{ bar: &'b &'a i32 }
// signature (all generics specified)
fn foo<'a>(FooStruct { bar, .. }: FooStruct<'a, '_>, baz: i32) {
    // use (bare struct name without any generics specified)
    foo(FooStruct { bar: bar }, baz)
}

[mendelsshop]

I think I won't support doing it for self parameters, as that would be too much of a change. You have to possibly move the function out of the impl block and update all the references to be normal function calls. And this can be done in two steps, first by renaming self and the using this code assist.

Also, should I be copying relevant where clauses? My reason not to do that is that I think it is common to put where clauses on functions and leave the types alone. But when we copy the generics parameters from the function we also copy any bound that are on the generics directly, like <A: Copy>.

[mendelsshop]

It's mostly working, there are a few things I could not figure out how to do:

If there is a comment in between two parameters, I cannot move into the struct definition between the corresponding fields.

Also for a case like this:

struct Foo<'a> { baz: &'a i32 }
fn bar(foo: Foo) {}

How do I detect that the Foo type in bar is missing lifetime arguments so I can add explicit lifetimes for it?

And I assume I should remove the "feat: extract_struct_from_function_signature" header from all my commit messages?