Assist: create function stub

[lnicola]

E.g.

x.foo(bar, qux(), qux());
// ->
// impl X {
// ...
fn foo(&self, bar: Bar, qux_1: Qux, qux_2: Qux) {
    todo!();
}
// ...
// }

[TimoFreiberg]

Adding basic function (not method) stubs works now.

Next steps (in a rough cost/benefit priority order, off the top of my head):

• [Done! Make add_function generate functions in other modules via qualified path #3998] creating functions in another module of the same crate.
  E.g. when typing some_mod::foo<|>(...) when in lib.rs, I'd want to have foo generated in some_mod.rs and jump there.

• [Done Introduce HirDisplay method for rendering source code & use it in add_function assist #4175] refer to arguments of the generated function with a qualified path if the types aren't imported yet

• make sure the generated names are always snake_case
  Should be quite easy, important to make it not feel janky.

• function reference/closure arguments: Their type isn't printed properly right now.
  The "insert explicit type" assist has the same issue.
  Not sure how hard, important for completeness.

• add type arguments of the arguments to the generated function
  (generating foo via foo(bar()) with fn bar<T>(...) -> T should generate fn foo<T>(bar: T). Right now it generates fn foo(bar: T))
  Not sure how hard, important for completeness.

• create method (self.foo<|>(..) or some_foo.foo<|>(..)) instead of create_function.
  The main difference would be finding (or creating) the impl block and inserting the self argument correctly
  Medium difficulty I guess, important for completeness, .

• generating proper names for all kinds of argument expressions (if, loop, ...?)
  Without this, it's totally possible for the assist to generate invalid argument names.
  Should be quite easy (may be a slog though), medium importance to make it not feel janky.

• (fixed via Support snippet text edit #4494) select the generated placeholder body so it's a bit easier to overwrite it
  The WIP snippets implementation in coc-rust-analyzer properly selects the generated todo!()

• Refine placement of the generated function.
  Currently it's placed behind the last element of the surrounding module/file.
  That means it's after test modules etc, which is probably not what the developer wants.
  We would need a "most sensible place for a new function" heuristic.
  Not sure how hard, probably not easy. In very big files this feature might make a big ergonomics difference.

• more specific default arg names for literals.
  So far, every generated argument whose name can't be taken from the call site is called arg (with a number suffix if necessary).

• When using the name of the passed argument, nested expressions should probably be ignored
  Example: when generating foo out of foo(Some('x').map(|it| it.toUpper())), the arg name should rather be map than to_upper.

• Generate only the minimum necessary whitespace around the function.
  In the initial version, the generated function is inserted with newlines before (and in Make add_function generate functions in other modules via qualified path #3998, sometimes also newlines after). If there is already enough whitespace at the placement spot, it would be cleaner to do something so the generated function doesn't end with 3 empty lines behind it.

• Offer the create_function assist for other function references than calls.
  Example: some_iterator.map(foo<|>) should offer to create foo if it doesn't exist and infer the expected parameters.

• Autocomplete functions with information from unresolved calls (see Add create_function assist #3746 (comment))
  Issues: see Add create_function assist #3746 (comment). The unresolved call could be anywhere. But just offering this autocompletion for unresolved calls in the same module would already be cool.

[lnicola]

generating proper names for all kinds of argument expressions (if, loop, ...?)

I think naming them based on the type would work better, but there still are some corner cases (e.g. tuples and unnameable types).