Nullish coalescing should always include the type of the right operand

$ ./node_modules/.bin/tsc --version
Version 3.7.2

Search Terms:

Code

A toy example would be something like this.

let foo: string = "";
foo = "bar" ?? 123;

This one is obviously fine since "bar" is always truthy.

However, this becomes a little bit problematic when you consider the idiom of having Record objects and checking their truthiness before using them.

const elts = ["foo", "bar", "spam", "spam", "foo", "eggs"];
const counts: Record<string, number>;
for (const elt of elts) {
  // This really **should** raise an error.
  counts[elt] = counts[elt] ?? "zero";
  counts[elt] += 1;
}

Expected behavior: An error should be raised.

Actual behavior: Curiously, an error is not raised in strict mode but is raised in un-strict mode.

$ ./node_modules/.bin/tsc ./foo.ts 
foo.ts:5:3 - error TS2322: Type 'number | "zero"' is not assignable to type 'number'.
  Type '"zero"' is not assignable to type 'number'.

5   counts[elt] = counts[elt] ?? "zero";
    ~~~~~~~~~~~


Found 1 error.

$ ./node_modules/.bin/tsc --strict ./foo.ts
# No error, exits 0 and emits JS.

Playground Link: Playground Link

Toggling the strictNullChecks config option will show the issue.

Related Issues:

[jcalz]

This is probably related to or a duplicate of #13778.

With --strictNullChecks on, the compiler assumes that counts[elt] must be of type number, which is never null or undefined. If you want the compiler to notice that counts[elt] may be undefined, then you (currently) need to include undefined in the property type manually:

const counts: Record<string, number | undefined> = {};
for (const elt of elts) {
  counts[elt] = (counts[elt] ?? "zero"); // error now
  counts[elt] = (counts[elt] ?? 0) + 1; // okay
}

Playground

With --strictNullChecks off, the compiler never assumes nullish coalescing will short-circuit because it can never eliminate null and undefined. See this comment from the PR

[travigd]

I respectfully disagree (obviously - I created the issue 😉). Using too-loose Record types is a common idiom in TypeScript, and I think changing this behavior makes that idiom easier to work with.