Nested try block breaks type checking

[warrenfalk]

TypeScript Version: 4.0.0-dev.20200612

Search Terms: nested try

Code

type State
    = {tag: "one"}
    | {tag: "two"}
    | {tag: "three"}

function notallowed(arg: number) {
    let state: State = {tag: "one"};
    try {
        state = {tag: "two"};
        try { // <- this inner try causes a problem
            state = {tag: "three"}; // <- this should make "three" be a possibility but when inside a try, typescript "forgets" it.
        }
        finally {}
    }
    catch (err) {
        state.tag; // <- this should be "one" | "two" | "three" but typescript says it is "one" | "two"
        if (state.tag !== "one" && state.tag !== "two") {
            console.log(state.tag); // <- typescript reports a type error here
        }
    }
}

Expected behavior:

The example code should compile without error.

Actual behavior:

The compiler reports a type error as though the code in the inner try can't happen

Playground Link:

https://www.typescriptlang.org/play/#code/C4TwDgpgBAysCGwICgpqgXigbwQcwC4oAiAewDsJiBfVdAHx3yOOAHdSa61Hd5CSwABYAnCFVrIAZgFdyAY2ABLClHKkEAG02k2EACYAKeCIHkZAWwBGEEQEoc3KJojAoAZwRIicRNCx8AmSUNADcTsAiII7osR5e-kz8LOyc1OFx6JHR2FAA9HlQADwAtFDCSu5QSuSUIuVRUPLwMu4QVfBQYCKkVi4WTplonn6YSUHCYhKh+YWl5eDt8iJKYG5SpKauVRVVzeRQQvBgkAdsQhAHSm6V1eTuSvrQuw0gg+i0Q1BSNfDaOZ8Pk5msB5EIoIZbPYYkMRkgAHT4GYFYplF7uISkGSafRQGwkChUKCMVgcYjEwSicTkqwyNygSDuZarNzueAgKrXapVYJEkmpYjvNBKKQQuEQRH8KAAQgwWF55IAZIr4n5JXgZXLBGSHNghXF5BR3KQXPCdHhDOL1XZkXM0YsmSs1lAxGBNsAOgtIFAoZtDrYUF9AWhaJJZAplKo-jo9EYTGZLDZoXrYi5WQkfAkxoEWISwhFGinYVmAsxtWkMkM8gAqbLVwq5FHzMQWUgAN2eQluNTqryg8HIuK5HBEAGt3AAaH0dg7CLF4cFcjFYnFqDRQCzwUfQAfRfQiqQBhTQC5ifWxcXZsusKnTWaoqBsa6Yul3XvZKcMpZO1niHZdjoqjddwHj6aArBEAcwX1YM4hrH5yGjEB6xwWDYJBMEIShXV9StJF73mF5bgVClSU4UjJmpftOVZF9VxsfURTFBJ1U1eU8ygZVVQRfA2PLYgcK+WJDXuE0JXNS0WPwG0CLKdQfREHp6lUF5CRgpxQ2QIA

Related Issues:

[fatcerberus]

I was going to say that the final type should probably be "one" | "three" since there's no scenario in which the catch can observe two, but TS is probably just assuming that any statement can throw, which is fair.

[Git-Lior]

this seems to be a broader problem with try...finally blocks without a catch clause, for example:

function test() {
    let x: 1 | 3 = 1;
    try {
        x = 3;
    }
    finally {}

    if (x === 1) { // typescript reports an error here
        console.log("this can happen");
    }
}

Playground Link

if you add an empty catch block before the finally block this is resolved correctly.

[fatcerberus]

Adding a catch to the Playground example in the OP doesn't help. So maybe there are two separate bugs?

[ahejlsberg]

@Git-Lior Your example is being analyzed correctly. The only way control can reach the code past the finally block is when the try block completes normally, and at that point x always has the type 3.