Type inference/narrowing lost after assignment

TypeScript Version: 3.1

Search Terms: type inference, type guard, narrowing, lost, assignment

Code

let a: unknown = 'x';

if (typeof a === 'string') {
  // a inferred as `string`
  a = a.substr(0, 5);  // (method) String.substr(from: number, length?: number): string
  // a inferred as `unknown`
  a.length;            // Failure: Object is of type 'unknown'.
}

Expected behavior: This should compile without an error.

Actual behavior: Line 7 fails with: Object is of type 'unknown'.

Playground Link: https://www.typescriptlang.org/play/index.html#src=let a%3A unknown %3D ‘x’%3B if (typeof a %3D%3D%3D ‘string’) { %2F%2F a inferred as `string` a %3D a.substr(0%2C 5)%3B %2F%2F a inferred as `unknown` a.length%3B }

Related Issues: #18840, #19955, #26673

[AlCalzone]

I just stumbled into this aswell, albeit with number instead of string. I can’t see any logical reason why assigning a number to a value we know for sure to be a number should require us to narrow again:

declare function takesNumber(value: number): void;

function test(value: unknown) {
  if (typeof value !== "number") return;
  takesNumber(value); // ok
  value = 1; // assign the same type!
  takesNumber(value); // error (value is unknown, although we narrowed it to number before)
}

I would really love to have an unknown type that is less cumbersome to work with. It has been really awkward since it was introduced almost 3 years ago and not much has changed 😦.

[corymharper]

I also ran into this issue today while trying to use unknown. It’s rather fine that assignment itself doesn’t narrow types, that would just be nice. However, the unintuitive part for me is that it actually broadens an already narrowed type. So if I have type checked that I am working with an array, if at any point I do a reassignment on that variable, I’ll lose the narrowing that has already been done and have unknown again. I’m left with the option of creating a new variable after doing the type narrowing and assigning it to the now narrowed variable, then the type for that variable will be inferred as the correct type, which is just really awkward and creates unneeded variables.

For arrays in Javascript this is particularly noticeable if you have broken down multiple method calls onto separate lines using reassignments, you just can’t do it if the variable was originally of type unknown.