CFA should consider branch flags

[tinganho]

This is a suggestion to improve the CFA. It would be good if TypeScript considered branch flags when analysing code paths.

function f() {
    let text: string;
    let hasTakenVerySpecificBranch = false;
    if (0.5 < Math.random()) {
        if (0.5 < Math.random()) {
            if (0.5 < Math.random()) {
                hasTakenVerySpecificBranch = true;
                text = '';
            }
        }
    }
    if (!hasTakenVerySpecificBranch) {
        text = ''
    }
    console.log(text); // Error 'text' is used before assigned.
}

We assign text on all possible code paths above. And it shouldn't error above.

A branch flag is simply a boolean variable that is considered when doing the control flow analysis.

[RyanCavanaugh]

Unless there's some simple way to do this that I'm missing, it seems almost incredibly complex to track all the possible interactions of variables as the function runs.

[tinganho]

Maybe you are thinking about a more generic case of taking into consideration all variable assignment types?

I was thinking about just :

1. Mark variables that is initialized to false as candidates for branch flags.
2. Detect true assignment branches.
3. Check if there is catch-all-but-true branch. (if (!hasTakenVerySpecificBranch))
4. If and only if a variable is assigned on catch-all-but-true and all true branches then narrow the types to the corresponding assigned types.

I detected 3 places in my code that could benefit from this. The workaround I do right now is to define the variable as string | undefined and use the non-null assertion operator everywhere. This can get ugly quickly if you use the variable in a lot of places.

I think the pattern of using branch flags is quite common. The variable hasTakenVerySpecificBranch is really part of the control flow like the if, else if and else statements are and should be treated equally in CFA.

[tinganho]

Hmm, after thinking about it a bit, a branch flag can have have more values than just two:

const enum Animal {
    Unknown,
    Cow,
    Pig,
    Chicken,
}

interface IAnimal {
    type: Animal;
    age: number;
    sound: string;
    legs: 2 | 4;
}

function detectAnimal(sound: string, age: number): IAnimal {
    let type = Animal.Unknown;
    let legs: 2 | 4;
    if (age > 1) {
        if (sound === 'quack quack') {
            type = Animal.Chicken;
            legs = 2;
        }
        if (sound === 'nöff nöff') {
            type = Animal.Pig;
            legs = 4;
        }
    }
    else {
        throw new Error('Animals do not make sound at age lower than 1.');
    }
    if (type !== Animal.Chicken && type !== Animal.Pig) {
        legs = 4;
    }
    return {
        type,
        age,
        sound,
        legs, // Error 'legs' is used before assigned.
    }
}

I could probably put up a more detailed proposal.

[ejose19]

This could be useful for the following cases:

const condition = true; // <-- can be obtained differently, the point is that it's a constant
let message: string;

if (condition) message = 'hello';

// Some shared code that runs independently of condition

if (condition) console.log(message); // <--- this gives error "message is not defined"