Use-before-assigned analysis does not account for functions returning never

[tjhance]

TypeScript Version: 2.0.3

Code

With --strictNullChecks,

function throwError(): never {
  throw new Error();
}

let a: number;

if (Math.random() > 0.5) {
  a = 5;
} else {
  throwError();
}

console.log(a);

Expected behavior:

I expect that, since throwError has return type never, that TypeScript would be able to deduce through control flow analysis that a has been initialized when console.log(a) is called.

(This works as expected if the throwError(); line is replaced with the more direct throw new Error().)

Actual behavior:

I get an error

a.ts(13,13): error TS2454: Variable 'a' is used before being assigned.

[aluanhaddad]

There is a difference between a function typed as () => never and to saying that a call to that function implies always throws. But practically, I guess they mean the same thing.

If the compiler were to do this, wouldn't it also make sense that calling such functions unconditionally should change the callers inferred return type to never? That does not happen today, I don't know if it is by design.

function f(): never {
  throw Error();
}
function g() {
  f();
}

In the above f has type () => never, but only because I annotated it as such, while g has type () => void. If you were reviewing this code, you would probably think that calling g indicates a programmer error unless it actually through some conventional NotImplemenetedError.

[gcnew]

TypeScript uses the shape of the code, not the types in this case. See #10973 and #10973 (comment)

PS: This crops up every now and then, maybe the TS team will revisit whether they can make it work.

[mhegazy]

indeed a duplicate of #10973