Repository: TypeScript
Issue: Add Inline value provider api for debugging 
Labels: Suggestion,In Discussion

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