Debugger: show variable values as inlay hints

[PaulKlint]

In the debugger we want to optimize the amount of user-interaction that is needed to get relevant information.
Hovering over a variable name and getting its value as a pop-up mini-window is already great.

I propose to provide the current values of variables as inlay hints as in:

void main(){
         int y = 1; 
         for(int x <- [1..10){  // inlay-hint x = ...
               y += x;          // inlay-hint y = ...
         }
}

Points to ponder:

• If values are too large this may become a mess, may be only do this when textual size is below a fixed threshold
• If these values are shown for all variables it may also become a mess, so a policy is needed to restrict the display of these hints:
  -- Only when hovering over a line?
  -- Only when at a breakpoint?
  -- Provide a filtering mechanism to restrict the variables to show?

[jbdoderlein]

I just discover that VSCode have a default inline values provider that use information from DAP.
The option debug.inlineValues is by default auto, which only show inline value if the language provides a custom inline values provider.
When switched to on, VSCode use variable information from DAP and syntax to provide inline values :

To provide inline values with more control and with auto configuration, the extension needs to define a custom inlay value provider.
For example, Python VSCode implementation : https://github.com/microsoft/vscode-python-debugger/blob/d7b96430e7dda95cc3d6565364e3639a2b9501c3/src/extension/debugger/inlineValue/pythonInlineValueProvider.ts
The calculation of these inline values can be done in Rascal with a custom DAP requests

[DavyLandman]

How do we know from which debugger session we should ask the values? You can have multiple debugging sessions connected for example.

[jbdoderlein]

The data come from the focused DAP session, the provider is linked to the DAP : each debug session(i.e. DAP server) has a different inline value provider, that can interact with DAP.

The default inline values are displayed only on syntax matching with variable name provided by DAP variables requests (exactly like the hovering over a variable) :

[DavyLandman]

I mean if we add this to LSP and we get the request for module X and there are 3 REPLs open, with 2 of them a running their ow DAP server, how do we from the LSP side know which of those 2 REPLs we're going to ask about module X?

[jbdoderlein]

The provider is register throught vscode.language.registerInlineValuesProvider, and documentation say :

... Whenever the generic debugger has stopped in a source file, providers registered for the language of the file are called to return textual data that will be shown in the editor at the end of lines....

So the request is only done if there is a debugger in a suspended state. There is no information about which debugger to ask because we could in fact collect information from every debugger that is launched.
However, the common approach is to use vscode.debug.activeDebugger as the DAP that will provide information.

[DavyLandman]

However, the common approach is to use vscode.debug.activeDebugger as the DAP that will provide information.

rascal-lsp lives in java, we don't have vscode.debug.activeDebugger available I think? So that should be something we extend our LSP with. it'll be fun to implement this feature I guess.

[jbdoderlein]

This is not part of the LSP ! It's a VSCode feature (like TerminalLinkProvider).
Iin fact we could implement this in Typescript only inside the VScode extension, but the cleaner way would just be to make a custom request on the DAP server that have all information, and so we would only need a minimal wrapper code in Typescript to make the request and put the result inside vscode API.

[DavyLandman]

Isn't the inlineValue LSP call meant for this?

[jbdoderlein]

Yes and no.

From what I see in documentations and other language implementation, LSP inlineValue are usually used for static or lightweight computation value display. Since it's part of the LSP, there is no control or information about a runtime.

On the other hand, VSCode InlineValueProvider is attached to the DAP protocol (not part of it). It is only trigger in the context of a debugger stopped somewhere. It will make DAP requests to get information and will be sync with it.

A language with integrated LSP/DAP could use LSP inlineValue to provide information about the current runtime of the DAP. Or even use information from any runtime running. However, I never saw any example of this, even Java LSP/DAP register a custom (DAP) inlineValueProvider to vscode.

The VSCode/DAP allow the extension to return for a document a list of InlineValue corresponding to a range in the document that are :

• InlineValueText : Tell vscode to display some text next to the range
• InlineValueVariableLookup : Tell vscode to display the variable next to the range. The variable name must be part of the response of the DAP variables request
  InlineValueEvaluatableExpression : Tell vscode to display the result of the expression next to the range. The expression will be evaluated by the DAP evaluate request

This wrapper is mainly to allow the language extension to "filter" what to display to each range, to ensure scope rules or other constraint for example.