Repository: TypeScript
Issue: Refactoring: Generate type annotation from inferred type
Labels: Suggestion,Awaiting More Feedback,Domain: Refactorings

## Search Terms

<!-- List of keywords you searched for before creating this issue. Write them down here so that others can find this suggestion more easily -->
refactoring
quick
fix
add
inferred
type

## Suggestion

VS Code should provide a refactoring command for generating a type annotation.

## Use Cases

In our code base, we use the TSLint's [typedef rule](https://palantir.github.io/tslint/rules/typedef/) to enforce type annotations.  For example:

```ts
// TSLINT ERROR
const map = this.getMap();
const value = map.getValue(someKey);

// GOOD
const map: Map<string, CatalogItem> = this.getMap();
const value: CatalogItem = map.getValue(someKey);
```

It's true that these types can usually be inferred by the compiler.  However, requiring people to write  explicit annotations makes code more readable, especially in situations where IntelliSense is unavailable.  For example:  When reviewing a GitHub pull request, or printing a Git history, we get no help from IntelliSense.

## Details

VS Code should provide a refactoring command for generating a type annotation.  For example, if I right-click on `map` in this code...
```ts
const map = this.getMap();
```
...then I should be able to do `Refactor -> Add Type`, and it will convert it to the good form shown above.

Although this is a super easy operation for the compiler engine, I cannot seem to find an implementation of this feature.  

I found a couple projects [typescript-plugin-add-type](https://github.com/cancerberoSgx/typescript-plugins-of-mine/tree/master/typescript-plugin-add-type) and [typescript-plugin-proactive-code-fixes](https://github.com/cancerberoSgx/typescript-plugins-of-mine/tree/master/typescript-plugin-proactive-code-fixes).  However, they aren't usable:
- They aren't maintained any more
- The latest release is incompatible with the latest VS Code
- They are modeled as **compiler plugins**

Representing refactoring operations as **compiler plugins** doesn't seem like the best design:
- The refactoring engine will malfunction unless the `npm install` is in a good state, which is not always the case for a project that is "under construction"
- The plugin will have to be added separately to each project.  It would be much more convenient to install it once (e.g. a VS Code extension), and then be able to use it anywhere.

Since the implementation is relatively simple, this seems like a good candidate for a built-in feature.

## Checklist

My suggestion meets these guidelines:

* [x] This wouldn't be a breaking change in existing TypeScript/JavaScript code
* [x] This wouldn't change the runtime behavior of existing JavaScript code
* [x] This could be implemented without emitting different JS based on the types of the expressions
* [x] This isn't a runtime feature (e.g. library functionality, non-ECMAScript syntax with JavaScript output, etc.)
* [x] This feature would agree with the rest of [TypeScript's Design Goals](https://github.com/Microsoft/TypeScript/wiki/TypeScript-Design-Goals).