Surprising behavior with typeof in signatures

[ajafff]

TypeScript Version: 2.9.0-dev.20180323

Search Terms:

Code

declare let foo: number;

// bar is of type string
// return type is string
declare function test(foo: string, bar: typeof foo): typeof foo;
// bar is of type string
// return type is number
declare function test({foo}: {foo: string}, bar: typeof foo): typeof foo;

Expected behavior:

typeof foo should reference the same declaration regardless of where it's used in the signature.

Actual behavior:

typeof foo in return type refers to the outer variable if foo comes from a destructured parameter. typeof foo inside the type annotation of another parameter refers to the parameter as expected.

This becomes even more visible if you remove the outer declare let foo: number; which will result in a compile error: Cannot find name 'foo'.

Playground Link: http://www.typescriptlang.org/play/#src=declare%20let%20foo%3A%20number%3B%0A%0Adeclare%20function%20test(foo%3A%20string%2C%20bar%3A%20typeof%20foo)%3A%20typeof%20foo%3B%0Adeclare%20function%20test(%7Bfoo%7D%3A%20%7Bfoo%3A%20string%7D%2C%20bar%3A%20typeof%20foo)%3A%20typeof%20foo%3B

Related Issues:
#22769 possibly related issue where the parameter initializer refers to the wrong variable.

[ajafff]

It gets even weirder if you reference variables in the function body:

declare let foo: number;

// bar is of type string
// return type is number
function fn(bar: typeof foo): typeof foo {
    var foo = '';
    return bar; // compile error: string is not assignable to number
}

But if you change var to let it surprisingly works completely different:

declare let foo: number;

// bar is of type string
// return type is string
function fn(bar: typeof foo): typeof foo {
    let foo = '';
    return bar; // no compile error
}

[ghost]

In declare function test({foo}: {foo: string}, bar: typeof foo): typeof foo;, there is an error at the second foo: src/a.ts(1,70): error TS2304: Cannot find name 'foo'.. You might have been confused because of #22790 ?

[ghost]

I'll still mark this as a bug because I would expect the second example to have the same behavior regardless of whether you write var foo or let foo inside the function.

[ajafff]

@andy-ms

there is an error at the second foo

If you copy and paste the whole snippet including the declare let foo: number; there will be no error.

Also that's what I meant with this note in the OP:

This becomes even more visible if you remove the outer declare let foo: number; which will result in a compile error: Cannot find name 'foo'.

[ghost]

Ah, OK. So the problem is that we do name lookup differently in the return type vs in the parameter.

[ajafff]

So the problem is that we do name lookup differently in the return type vs in the parameter.

Exactly. At least it should be consistent and not change if a parameter is destructured.