From https://github.com/microsoft/vscode/issues/119489 ## Background The new [inline value api](https://github.com/microsoft/vscode/issues/105690) for VS Code lets language extensions tell the debugger which values should be shown directly in a file while debugging. Without this API, VS Code uses a generic method for determining which values to show. This ends up showing many irrelevant values to the user See https://github.com/microsoft/vscode/issues/119489 for an example of this ## Feature Request We'd like to use the TypeScript server's language smarts to implement the [VS Code inline value api](https://github.com/microsoft/vscode/issues/105690) so that only relevant values are shown. Here's a potential shape of the API based on the [vscode inline value API](https://github.com/microsoft/vscode/issues/105690) ```ts // For debugging, we request inline values at a specific location in a file interface InlineValueRequestArgs extends FileLocationRequestArgs {} interface InlineValueResponse extends Response { body: InlineValue[]; } // Support two types of inline values: simple ones that can be looked up by name, and more complex ones // that require evaluating an expression type InlineValue = InlineValueVariableLookup | InlineValueEvaluatableExpression; // A value that can be looked up by name. // This is mostly just an optimization for a common case of inline values interface InlineValueVariableLookup { // Span in code of the identifier readonly span: TextSpan; // Optional variable name to look up. If not specified, uses the name from `span` // TODO: Is this needed for TS? readonly variableName?: string; } // A value which is shown by evaluating a given expression interface InlineValueEvaluatableExpression { // Span in code of the expression readonly span: TextSpan; // Optional expression to evaluate. If not specified, uses the expression from `span` // TODO: Is this needed for TS? readonly expression?: string; } ``` ## Behavior Some notes on how the inline value provider should work (copied from @connor4312): - The debugger should handle source maps, so the provider should only have to worry about the requested file - Inline values should only be provided in the current and parent scopes - Declarations and assignments assignments should evaluate the declared or assigned expression, `bar` in `bar = foo()` or `foo` in `function foo() {}` - Conditional expressions (ternary or `if` statements) should evaluate the conditional and none of its children, `!foo && bar` in `if (!foo && bar)` - Property assignments should be evaluated, `foo()` in `{ x: foo() }` Here's a small example of some inline values: ```ts function double(n: number) { // eval('double') -> double() return n * 2; } let x = 1; // InlineValueVariableLookup for x here if (x === 2) { // eval(x === 2) -> false x *= 2; // this line should NOT be evaluated since it's not the scope or its parents } if (x === 1) { // eval(x === 1) -> true x *= 2; // InlineValueVariableLookup for x here const y = { z: x ** 2, // eval(x ** 2) -> 16 }; console.log(x); // <-- paused here } ``` @connor4312 Is handling this on the VS Code side and should be able to answer any questions regarding this API /cc @weinand