Function completion for parameterless functions can delete a typed closing parenthesis

[tristanlabelle]

Compare C# and Swift:

Note that the completion list is still visible after the ( in the Swift case, whereas C# transitioned to parameter completion. It's not too bad in this example, but it leads to weird behaviors in others, like typing foo() and hitting enter:

Compare with C#:

I believe the fix is to specify commitCharacters = [ '(' ] on the CompletionItem at https://github.com/apple/sourcekit-lsp/blob/8cb76ba22a53bfe4b21575200fd5d930a931eb18/Sources/SourceKitLSP/Swift/CodeCompletion.swift#L173 . Or to use CompletionOptions.allCommitCharacters in initialize.

[ahoppen]

Tracked in Apple’s issue tracker as rdar://112835664

[ahoppen]

The reason why we didn’t add ( to the commit characters for code completion is that we don’t want code completion to automatically show up when you type the opening ( of a parenthesized expression or tuple, so I am curious to see what the C# extension does there. Which C# extension do you have installed and do you need to add some surrounding files to get C# completions? I tried installing the C# extension from Microsoft and creating a .cs file containing

void Foo(int x) {}

and then performing the completion you suggested. But I seem to only get textual completions.

[tristanlabelle]

The reason why we didn’t add ( to the commit characters for code completion is that we don’t want code completion to automatically show up when you type the opening ( of a parenthesized expression or tuple

For many versions now LSP has distinguished "trigger characters", which start a code completion session, from "commit characters", which cause a code completion session to commit the current selection. If ( is a commit but not a trigger character, we should get the desired behavior. . would be an example of a character that should be both trigger and commit. I think that, for legacy reasons, trigger characters are also used as commit characters, but not the other way around.

Which C# extension do you have installed and do you need to add some surrounding files to get C# completions?

Microsoft just released "C# Dev Kit" which builds on top of C# (which I have at v1.26.0). You might want both to get all features.

do you need to add some surrounding files to get C# completions?

Possibly, try running dotnet new console and opening the directory in vs code. That will create a .csproj file which may be necessary for full language services.

[ahoppen]

Thanks for the hint to install “C# Dev Kit”. I was able to reproduce what you’re seeing with it.

Hera are a couple of notes from my investigation.

1. The first screen recording you showed is actually not technically an LSP completion in the classical sense. AFAICT, it’s the completion from CodePilot, which has its own UI implementation to display the suggestion like it does. You can see this by typing

void Foo(int x, int y) {}
Foo(2, <complete>)

which suggests Foo(2, 3); for me, surely a AI-generated completion. So comparing that to SourceKit-LSP is a little bit like comparing apples to oranges and not that meaningful.
2. Adding ( to the trigger characters doesn’t work out of the box because it will cause the foo() completion to get accepted when you type (. We thus end up with foo()() (foo() from the accepted solution and () from the typed ()
3. I think what confuses you is that completion items are suggested that produce an empty text edit. If we filtered those completion results, we wouldn’t hit the case of your third screen recording anymore. WDYT?

[tristanlabelle]

You're right that copilot was active, but what I meant to show is that there is no more completion list in C# after typing (, whereas there is still one in Swift. Although studying this more closely, I understand that Swift has a two-phase completion: one for the function name, and one for offering the snippet. I think that's fine except for the bug with parameterless functions where typing foo() and enter to accept the () suggestion will replace the typed text with foo(. I think I ran into some other odd cases but they aren't described well here so I'll loop back when I pin them down better.

I'll rename this issue to focus only on the foo() case.