CompletionItem - multiple text edits, onDidAcceptCommand

[jrieken]

We should investigate if we should allow running a command on suggest. That would allow for more advanced code actions, like 'add import', 'download typing files' etc on completion. An alternative would be the onDidExecuteCommand event which folks ask for. Internally accepting a completion is a command - if we broadcast that someone else could run a followup command.

[jrieken]

[onWill|onDidExecuteCommand] is tracked here: #1431

[dbaeumer]

I like the idea of running a command since it allows for cases like downloading a typings file. But there are lot of cases as well that only need to apply multiple edits. Could we have both, providing an array of edits or an command.

[jrieken]

yes - I came to the same conclusion, esp when a command also wants to modify the current text document. Coordinating a command and a text edit would be hairy...

[dbaeumer]

Agree on the coordination command and text. That is why I would do exclusive or.

[jrieken]

@DustinCampbell fyi

[DustinCampbell]

sounds great!

[jrieken]

Also, there is a little know thing with completions and that is placeholders... It's undocumented and somewhat internal but it would be easy to make it like snippets. That is a completion can contain placeholders, tab positions, and the final cursor position. Like so:

foo(${value}, ${another}); ${_}

It would do something like this:

For instance for method completion a powerful language brain could already propose arguments for function calls etc

[buehler]

I really like this idea. I'm currently at the state that I'm inserting the wanted symbol at the place with the CompletionItemProvider and then let the CodeActionProvider add the import reference. But actually it would be very nice to use the completion item to add the import to the document.

👍

Cheers

[jrieken]

@DustinCampbell @buehler We have a way to get into a 'snippet mode' when accepting a completion - that's multiple potentially linked cursors after selecting an item. We have them to help with subsequent edits and we plan to make them official (#3210). Snippet mode does conflict with additional edits and we will likely not allow both in one completion. Would that be a problem for you guys?

[buehler]

For now, fine by me :-)
For my actual usecase, it's cool to insert code at multiple lines (i.e. write the selected type and insert an import at the beginning of a file).

I dunno if this answers your question...

Cheers

[jrieken]

Yeah, thanks. Multiple text edits is definitely on our list, the import-scenario is what we are looking at but also want to think a little out of the box

[buehler]

Cool!
I don't get the "problem" with the snipped mode, could you elaborate the problem? It would be nice to understand your thinking.
So one can add multiple selections to edit several parts of the document at once with snippets?

[jrieken]

There is an undocumented feature which we lend from text mate snippets. Basically, you can use a special syntax in your completion and the editor will enter a snippet mode. See this sample:

...
new CompletionItem('bar{{foo}}bar{{foo}}{{}}')
...

The double-curly-bracket is somewhat internal but we plan to allow more of the text mate snippet syntax in completions. Combining that with additional edits is tricky

[DustinCampbell]

I'm primarily looking for a way to provide C# completion on override, which looks like so:

1. Before completion:

2. After completion:

Implementing this properly requires the following:

1. Multi-line completions
2. Multiple edits (for the using directive at the top of the file)
3. Ability to move the caret

I'm not sure snippets will achieve the desired result.

[buehler]

Oh shiny 👍
Thanks for the explanation.

[jrieken]

fyi @DustinCampbell

With this hacked-up completion item provider (note that the filter text must be set)

    languages.registerCompletionItemProvider('csharp', {
        provideCompletionItems(doc, pos) {
            const range = doc.getWordRangeAtPosition(pos);
            const word = doc.getText(range);
            if (word === 'override') {

                const item = new vscode.CompletionItem('M1()', vscode.CompletionItemKind.Method);
                item.textEdit = vscode.TextEdit.replace(range, 'protected override void M1()\n{\n\tthrow new NotImplementedException();{{}}\n}')
                item.additionalTextEdits = [vscode.TextEdit.insert(new vscode.Position(0, 0), 'using System;\n')];
                item.filterText = word;

                return [item];
            }
        }
    });

Still on my list

• use the 'official' text mate snippet syntax, so instead of {{}} it should be $0 for the final tab stop
• (stretch) make all textual changes happen in a single operation (single undo)

[nwolverson]

@jrieken I notice your current implementation has a command running after the text edit is made - I think that should enable my use case, where the additional edit (again inserting/modifying an import statement) is made via an external language service (ie provided asynchronously only after an individual completion is selected).

Am I right in that? I think it could be a common enough case.

[jrieken]

Yes and no. If you want to make additional modifications to the document I d recommend to use the additionalTextEdit-property. It will make you life easier wrt to subsequent edits, touching/overlaping edits, undo, keeping selections/multiple cursors stable etc.

is made via an external language service (ie provided asynchronously only after an individual completion is selected).

I'm obviously just guessing because I don't know anything about your language service but if you have a chance to compute those additional edits during the first request do it ;-)

Last, you might be interested in #10561 which is about expanding a snippet when being inserted.

[nwolverson]

@jrieken Unfortunately that's not possible if all edits must be provided for all completion items up front - rather than eg as a promise on the completion item (or at least the downsides you list are more acceptable than having to do so).

[jrieken]

Running an async aftermath command isn't a show stopper. Make sure to use small edits and compare the document version before and after the long running operation.

[DustinCampbell]

Very pretty @jrieken!

[jrieken]

Closing. The remaining work is #10561