+= on string | undefined should narrow its operand to string

[mhchem]

TypeScript Version: 2.6.1

Code

let a: string | undefined;
a = a + "a";
a; // string

let b: string | undefined;
b += "a";
b;  // should be string, but is still string | undefined

Expected behavior:
Both notations should be equivalend

[mhegazy]

we do not consider += / -= /today as narrowing operations.. moreover we explicitly allow + string on possibly undefined values to allow for debugging scenarios.. e.g. console.log("" + value). not sure why we allow +=..

[mhchem]

I don't mind how you treat this.
I have to admit that, undefined + "a" might be an common source for error (expecting "a", but getting "undefineda"). So not allowing this, might be a sensible solution.
But a = a + "a" and a += "a" must be treated 100% identical.

[RyanCavanaugh]

We tried to talk about this but argued about implicit coercion for half an hour instead...

[kujon]

@RyanCavanaugh what was the outcome of this argument? I feel like, at least in strict mode, typescript should disallow type coercion altogether. As it stands right now, it's quite inconsistent with what it lets through, e.g.

const foo = 42 + {}; // Operator '+' cannot be applied to types '42' and '{}'.
const foo = '42' + {}; // fine
const foo = {} + []; // Operator '+' cannot be applied to types '{}' and 'never[]'.
const foo = `${{}}${[]}`; // fine

[Rudxain]

IMO, template literals are "explicit enough" to not be considered coercion. But + must only allow homogenous operands.

Recently, I noticed noUncheckedIndexedAccess wasn't causing this code to be an error:

const NAME = 'foobar'
let chars = ''
chars += NAME[Math.random() * 0x10 | 0]

because, string + undefined is "valid"