Repository: TypeScript
Issue: Narrow type of variable when declared as literal (also tuples)
Labels: Suggestion,Needs Proposal

<!-- SUGGESTIONS: See https://github.com/Microsoft/TypeScript-wiki/blob/master/Writing-Good-Design-Proposals.md -->

**TypeScript Version:**  2.4.1

**Code**

The following doesn't compile, because `x` has inferred type `string`. I think it would be helpful if it did, but I still want `x` to have inferred type `string`:

```ts
function blah(arg: "foo" | "bar") {
}
let x = "foo";
blah(x);
x = "something else";
```

**Desired behavior:**

This would compile.

**Actual behavior:**

`demo.ts(4,6): error TS2345: Argument of type 'string' is not assignable to parameter of type '"foo" | "bar"'.`

**Suggestion**

The type of `x` should be inferred to be `string`, but it should be narrowed to `"foo"` via flow-sensitive typing, much like the below program:

```ts
function blah(arg: "foo" | "bar") {
}
let x = "foo";
if (x != "foo") throw "impossible"; // NOTE: codegen would NOT insert this
blah(x);
x = "something else";
```

Note that *this* program currently works as desired: `x` is still inferred to have type `string`, but the guard immediately narrows it to type `"foo"`. The assignment after the function call widens `x`'s type back to `string`.

My suggestion is for TS to treat declarations that assign variables to literals (as in the first example) to automatically perform this flow-sensitive type narrowing, without the need for an unnecessary guard.

I'm suggesting it only for declarations, not general assignments (so only with `let`, `var`, and `const`) or other operations. In addition, I'm only suggesting it for assignments to literal values (literal strings or literal numbers) without function calls, operations, or casts.

**Syntax Changes**

Nothing changes in syntax.

**Code Generation**

Nothing changes in code generation.

**Semantic Changes**

Additional flow-sensitive type narrowing occurs when variables are declared as literals, essentially making the existing

```ts
let x = "foo";
```

behave the same as (in checking, but not in codegen)

```ts
let x = "foo";
if (x != "foo") throw "unreachable";
```

**Reverse Compatibility**

Due to `x` being assigned a more-precise type than it was in the past, some code is now marked as unreachable/invalid that previously passed:

```ts
let x = "foo";
if (x == "bar") { // error TS2365: Operator '==' cannot be applied to types '"foo"' and '"blah"'.
  // ...
}
```

The error is correct (in that the comparison could never succeed) but it's still possibly undesirable.

I don't know how commonly this occurs in production code for it to be a problem. If it is common, this change could be put behind a flag, or there could be adjustments made to these error cases so that the narrowing doesn't occur (or still narrows, but won't cause complaints from the compiler in these error cases).

If the existing behavior is strongly needed, then the change can be circumvented by using an `as` cast or an indirection through a function, although these are a little awkward:

```ts
let x = "foo" as string;
let x = (() => "foo")()
```

## Tuples and Object Literals

It would be helpful if this extended also to literal objects or literal arrays (as tuples).

For example, the following could compile:

```ts
function blah(arg: [number, number]) {
}
let x = [1, 3];
blah(x);
x = [1, 2, 3];
```

with `x` again having inferred type `number[]` but being flow-typed to `[number, number]`. The same basic considerations apply here as above.

Similarly, it could be useful for objects to have similar flow-typing, although I'm not sure if this introduces new soundness holes:

```ts
function get(): number {
    return 0;
}
function blah(arg: {a: "foo" | "bar", b: number}) {
    // (...)
}

let y = get(); // y: number
let x = {a: "foo", b: y}; // x: {a: string, b: number}
// x is narrowed to {a: "foo", b: number}

blah(x); // this compiles due to x's narrowed type

x.a = "something else"; // this is accepted, because x: {a: string, b: number}.
```

See https://github.com/Microsoft/TypeScript/issues/16276 and https://github.com/Microsoft/TypeScript/issues/16360 and probably others for related but different approaches to take here.