`unknown` isn’t narrowed by assignment

Bug Report

🔎 Search Terms

try block

🕗 Version & Regression Information

• This is the behavior in every version I tried, and I reviewed the FAQ for entries about try-catch blocks

⏯ Playground Link

Playground link with relevant code

💻 Code

function f(request: {params: {[param: string]: unknown;}}) {
    let x = request.params.x;
    try {
        x = validate(x);
    } catch (e) {}

    try {
        takesString(x);  // Fails to compile, x is of type unknown.
    } catch (e) {}
}

function validate(x: unknown): string { return ""; }
function takesString(s: string) {}

🙁 Actual behavior

In this example, the code fails to compile because tsc has deduced x in the second block to be of type unknown

🙂 Expected behavior

Since we have successfully exited the first try-catch block, x’s type should be narrowed to string in the second.

[JonathanDCohen]

We lose type safety with any. In my case the type of params is used for all of our server’s endpoint handlers, so using unknown is useful to make sure we don’t skip a validation step. I think the true correct way to do this would be to do something like

function validate(x: unknown): x is string {
  // blah blah blah...
}
// ...
function f(request: {params: {[param: string]: unknown;}}) {
    let x = request.params.x;
    if (!validate(x)) { throw SomeError(); }
    // now x is narrowed to `string`
}

which is what I’ve switched to in my code.

[andrewbranch]

I think this is probably a better example of what you’re surprised by, if I’m understanding you.