Override completion should place cursor near arrow

[jcouv]

Currently, the cursor is placed at the end of the inserted code (as shown below).

At least in the case of a completion with an arrow body, that isn't most useful, since you won't type more statements in the body and you likely won't leave the inserted code as-is.

I'd propose that the cursor be left between the fat arrow and the inserted code.

This way, you could easily:

• convert the body to a block body,
• delete the body to type what you want.

Also, I think the override completion should not add a body when there is already one. This happens when you copy&paste one override method, then rename the method name.

[CyrusNajmabadi]

Another option: we should select hte code for the body we just generated. That way you can just immediately starting typing to overwrite it.

[sharwell]

I'd propose that the cursor be left between the fat arrow and the inserted code.

I like this because it enables both wrapping and Use Block Body scenarios. Though we normally wrap these before the arrow not after.

[CyrusNajmabadi]

Though we normally wrap these before the arrow not after.

Note: we really should just have a formatting option for this. :) We were hesitant originally because it was a new language feature and we didn't know how it would be used. At this point the major patterns are known and can be accounted for.

[Neme12]

Like @CyrusNajmabadi suggested, I would prefer if this just selected the expression in the body, because it's very likely that user will want to replace that. That way, the user can immediately start typing to replace the expression.

This way, you could easily:

• convert the body to a block body,
• delete the body to type what you want.

If we put the caret before the arrow, I'm not sure deleting the body is so easy (it requires moving a few characters right, and then selecting the whole expression). Converting the body to a block body should always be easy using the refactoring:

In fact this is often what I do before replacing the body.

[Neme12]

Actually, this issue mentions putting the caret to the right of the arrow:

I'd propose that the cursor be left between the fat arrow and the inserted code.

I was looking at the PR when writing the above comment, which implements caret to the left of the arrow. I'm a little confused. @jcouv ?

[jcouv]

You're correct, the PR puts the caret to the left of the arrow, so that the second scenario you listed becomes easier (deleting the body). I forgot to update the issue to reflect this. Sorry for the confusion.

There are three scenarios considered so far:

1. insert breakline before arrow,
2. convert the body to a block body,
3. delete the body to type what you want.

And some options:

1. caret on left of arrow (PR)
2. caret on right of arrow (initially proposed in issue)
3. select the expression (alternative proposal)
4. caret on right of expression-statement (status quo)

I think option 3 improves the third scenario (delete the expression), but worsens the first scenario (insert breakline) and second scenario (refactoring to convert to block doesn't trigger).

[Neme12]

(refactoring to convert to block doesn't trigger).

It does trigger, but you're right that the experience is worse because there are other additional refactorings and it's at the bottom of the list.

[jcouv]

It does trigger

What selection did you use?

Here's what I get when selecting the expression:

Selecting the expression-statement:

Selecting the arrow-clause:

[Neme12]

I see. I think it's probably because in my case, it is the use block body analyzer (which is always offered anywhere on the line) as opposed to a refactoring, whereas you might have different settings in Tools -> Options:

[jcouv]

From design meeting today:

• override completion should result in selecting the expression right-to-left (ie. caret on the left),
• convert to block body should trigger in that case.