Type of variable is narrowed immediately after definition

[DanielSWolf]

Bug Report

🔎 Search Terms

let, control flow, null, closure, lambda, arrow function

🕗 Version & Regression Information

• This is the behavior in every version I tried, and I reviewed the FAQ.

⏯ Playground Link

Playground link with relevant code

💻 Code

function execute(callback: () => void) {
  callback();
}

let value: string | null = null;

// At this point, immediately after its definition, the type of `value` has been narrowed to `null`.

execute(() => { value = 'test'; });

// Predictably, the type of `value` is still `null` here.

🙁 Actual behavior

Right after the line let value: string | null = null;, TypeScript narrows the type of value to null.

🙂 Expected behavior

Right after the line let value: string | null = null;, I would have expected the type of value to be string | null, as declared.

I understand that TypeScript performs narrowing when some operation might effectively change the type of a variable. But right after the definition of a variable, I'd like TypeScript to just trust my judgement. It's completely ignoring the type I explicitly specified, resulting in wrong typing.

[MartinJohns]

TypeScript narrowing it to null is intentional.
TypeScript not recognizing the assignment is a duplicate of #9998.

This is working as intended.

You can workaround this by using null as string | null.

[DanielSWolf]

I'm aware of the limitations regarding functions, but the null-narrowing behavior is new to me. @MartinJohns Can you point me to an issue containing the rationale?

[MartinJohns]

Honestly, I'm too lazy to look it up right now. :-D

But the rationale is simple. Just take this small example:

let value: number | null = 123;
value.toFixed()

Should this code compile? According to the type annotation it can be either number or null, but null does not have a toFixed function. But TypeScript can see that you always assign a number to it, so calling the function should work, right? That's the behavior you see. Assignment narrows the type of the variable to the assigned type.

And TypeScript treats variable initializations just as assignments. So it's essentially:

let value: number | null;
value = 123;

[jcalz]

Looks like a duplicate of #8513.

This is working as intended. Unions have been narrowed via control flow analysis since #8010.

[DanielSWolf]

@jcalz Thanks for pointing me at the right issues. This is indeed a duplicate of #8513. Closing.