Type of variable is inferred from literal instead of annotation

[JakenVeina]

Search Terms:
variable
literal
type inference
type annotation
TS2367
TS2339

Code

type Foo = number | "test";

let x: Foo = 5;
let y = <Foo>5;

function bar() {
    x = "test";
    y = "test";
}
bar();

if (x === "test") { // TS2367 This condition will always return 'false' since the types 'number' and 'string' have no overlap.
    console.log(x.length); // TS2339 Property 'length' does not exist on type 'number';
}
if (y === "test") {
    console.log(y.length);
}

Expected behavior:
No error should be produced here, since the variable x was declared to be of type Foo, not number, even though it was initialized with a number literal, it's not declared as a const and thus could change (and in fact does).

Actual behavior:
The compiler seems to infer the type of x as number, from the literal 5 used to initialize it, even though the variable type is explicitly declared to be of type Foo.

Playground Link:
Playground

Related Issues:
#26979
#10195

[RyanCavanaugh]

Your real complaint here is that the side effect in the function wasn't considered; see #9998.

Initialization is the same as assignment, so

let x: Foo = 5;

gets the same treatment as

let x: Foo = (whatever);
x = 5;

Given this, it would be ridiculous to error on

let x: Foo = (whatever);
x = 5;
x.toFixed(); // Error, Foo might be "test" ?????

[JakenVeina]

That's fair. I also think it's fair for the compiler to not recognize that side-effect. It can't investigate everything.

For context, the real-world scenario where this came up was...

interface ValidationErrorMap {
    readonly [errorCode: string]: string | ValidationErrorMap;
}

type ValidationResult = ValidationErrorMap | "success";

function combine(ReadonlyArray<ValidationResult>results): ValidationResult {
    let finalResult: ValidationResult = "success";

    for(const result of results) {
        finalResult = (result === "success") ? finalResult
            : (finalResult === "success") ? result
            : { ...finalResult, ...result };
    }

    return finalResult;
}

Here, I would definitely expect the side-effect to be recognizable, as it's happening in the same scope, just inside a loop.

[typescript-bot]

This issue has been marked as a 'Duplicate' and has seen no recent activity. It has been automatically closed for house-keeping purposes.