Flow-sensitive type narrowing does not extend into closures that are created after the narrowing is applied

[dead-claudia]

TypeScript Version: 3.3.3, 3.5.1, 3.6.3, 3.7.5, 3.8.2, 3.9.0-beta, and 3.9.0-dev.20200328 (every version in the playground at the time of writing)

Search Terms: flow-sensitive type closure

Expected behavior: No type errors

Actual behavior: In the return value for deferred, I got this error:

Type 'string | undefined' is not assignable to type 'string'.
  Type 'undefined' is not assignable to type 'string'. (2322)

Related Issues: Couldn't find any

Code

function immediate(value?: string): string {
    if (value == null) {
        value = "";
    }

    return value;
}

function deferred(value?: string): () => string {
    if (value == null) {
        value = "";
    }

    return (): string => {
        return value;
    };
}

Output

"use strict";
function immediate(value) {
    if (value == null) {
        value = "";
    }
    return value;
}
function deferred(value) {
    if (value == null) {
        value = "";
    }
    return () => {
        return value;
    };
}

Compiler Options

{
  "compilerOptions": {
    "strict": true,
  }
}

Playground Link: For nightly, but you can verify with other versions easily enough.

[dead-claudia]

Just to clarify: this is not related to cases like either of these:

function deferred(value?: string): () => string {
    if (value == null) {
        value = "";
    }

    function result(): string {
        return value;
    }

    return result;
}

function deferred(value?: string): () => string {
    const result = (): string => {
        return value;
    };

    if (value == null) {
        value = "";
    }

    return result;
}

It's only about cases where the function is created after the flow-sensitive cast, like the example in the bug as well as this:

function deferred(value?: string): () => string {
    if (value == null) {
        value = "";
    }

    const result = (): string => {
        return value;
    };

    return result;
}

[kitsonk]

Duplicate of #11498

[RyanCavanaugh]

This is specific to bindings which are mutable, and parameters are mutable bindings. The problem is that TS doesn't do an expensive forward-pass on the code to see if there are any subsequent assignments to value, so it can't disavow the possibility of code like this

function deferred(value?: string): () => string {
    if (value == null) {
        value = "";
    }

    const p = (): string => {
        return value;
    };
    value = undefined;
    return p;
}

[RyanCavanaugh]

The hypothetical performance-minded solution here would be to allow some kind of immutability annotation on the parameter, but the example kind of defeats that. Writing const v = value ?? "" and using v thereafter would be the recommended solution