`unknown` isn’t narrowed by assignment

[JonathanDCohen]

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]

I've discovered that

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

also fails to compile. So maybe the issue is related to narrowing the type of a variable in a broader scope?

[andrewbranch]

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

[JonathanDCohen]

Yes, that would do it.

[emilioplatzer]

I my opinion you are confused about unknown. If you see https://www.typescriptlang.org/docs/handbook/release-notes/typescript-3-0.html#new-unknown-top-type you can read:

Anything is assignable to unknown, but unknown isn’t assignable to anything but itself and any without a type assertion or a control flow based narrowing. Likewise, no operations are permitted on an unknown without first asserting or narrowing to a more specific type.

In your case you can use any to say I support any value. And then all works!

function f(request: {params: {[param: string]: any;}}) {
    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: any): string { return ""; }
function takesString(s: string) {}

Look at Playground

[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.

[emilioplatzer]

I like your point:

using unknown is useful to make sure we don't skip a validation step

I think you are right. Here is anohter example that ilustrates it: Playground

function validate(x: unknown): x is string {
    return typeof x === "string";
}

function mayBeNorS(): number|string{
    if(Math.random()>0.5) return 1;
    return 'x'
}
// ...
function f(request: {params: {[param: string]: unknown;}}) {
    let x = request.params.x;
    if (!validate(x)) { throw Error('some'); }
    // now x is narrowed to `string`
    x = "other";
    // now x is ruined to `unknown`
    x.toLocaleLowerCase();

    // if the original variable was not `unkonwn` it works!
    let y = mayBeNorS();
    y = "other";
    // now y is narrowed to `string`
    y.toLocaleLowerCase();
}

[rChaoz]

Worth noting this also happens with {}, not just unknown