LSP: add argument(s) to function

[nnuuvv]

I'm used to having a code action to add a new argument to a function based on usage.

i.e.:

fn wibble() {
            v - triggering "add argument to function" here
  wobble("wobble")
}

fn wobble() {
  todo
}

would change the code to this:

fn wibble() {
  wobble("wobble")
}

fn wobble(wobble: String) {
  todo
}

This, in my experience, is especially helpful when scaffolding mostly empty functions early in a new project.
As it allows quickly adding new arguments to a function call.

So instead of having to

• goto definition
• manually add function argument
• go back

I can just add argument to function and keep doing what i was doing and deal with it later.

Ideally this would work with multiple arguments at a time as well.

[nnuuvv]

alternative name: add argument to definition
or update definition

[lpil]

Hello!

When would this action be available?

What would happen when there already is some arguments for the function? How would it decide where to put them?

What would happen to all the other references to this function in the codebase?

So instead of having to

goto definition
manually add function argument
go back

I can just add argument to function and keep doing what i was doing and deal with it later.

Isn't this the same amount of work except the order in which the actions are performed at the same?

1. add argument to call site
2. run code action
3. continue editing
4. return to that call site
5. go to definition
6. rename argument
7. edit implementation

vs

1. goto definition
2. add parameter
3. edit implementation
4. go back
5. add argument to call site
6. continue editing

[nnuuvv]

Hi,

When would this action be available?

When there is at most 1 extra argument in a function call.

What would happen when there already is some arguments for the function? How would it decide where to put them?

I think there's 2 main scenarios

---

1. appending an argument

available when all but the last argument exist in the called function

fn wibble() {
  wobble("wobble", 123)
}

fn wobble(wobble: String) {
  todo
}

which results in

fn wibble() {
  wobble("wobble", 123)
}

fn wobble(wobble: String, value: Int) {
  todo
}

---

2. prepending an argument

available when all but the first argument exist in the called function

fn wibble() {
  wobble(123, "wobble")
}

fn wobble(wobble: String) {
  todo
}

which results in

fn wibble() {
  wobble(123, "wobble")
}

fn wobble(value: Int, wobble: String) {
  todo
}

---

There can be cases like these

fn wibble() {
  wobble("wibble", "wobble")
}

fn wobble(wobble: String) {
  todo
}

where it's unclear whether the first or last argument should be added.

In those cases the lsp could offer both options (that is what jetbrains rider does)

---

3.? arguments in between other arguments

I'm unsure how to best go about handling these; maybe not at all.

---

What would happen to all the other references to this function in the codebase?

There's 2 options

1. break them
2. don't offer the code action if there is other usages

I assume breaking usages is a no-go. Maybe offering it with a disclaimer that it will break usages would be ok?
Only having them when there's no other usages would be fine by me.

---

Isn't this the same amount of work except the order in which the actions are performed at the same?

It is a very similar amount of work, but the difference in order makes it easier to stay on task for me.

Edit: accidentally hit send
Edit2: excuse the somewhat silly answer; i was sleepy when i wrote it