Union types are not being narrowed correctly in generic functions in 4.3

[TomPeters]

Bug Report

Narrowing of a union type based on generic types does not work correctly in else branches in TS 4.3.

This likely relates to the changes made in #43183

🔎 Search Terms

generic, narrow, union types, 4.3

🕗 Version & Regression Information

This changed between versions 4.2.3 and 4.3

⏯ Playground Link

Playground link

💻 Code

function needsToNarrowTheType<First extends { foo: string }, Second extends { bar: string }>(thing: First | Second) {
 if (hasAFoo(thing)) {
 console.log(thing.foo);
 }
 else {
 // I would expect this to work because the type should be narrowed in this branch to `Second`
 console.log(thing.bar); // Error: Property 'bar' does not exist on type 'First | Second'.
 }

 function hasAFoo(value: First | Second): value is First {
 return "foo" in value;
 }
}

🙁 Actual behavior

In the else branch, the type of thing is First | Second.

🙂 Expected behavior

In the else branch. the type of thing is Second.

[fabb]

looks similar to my issue:

type Value = string | number | boolean | unknown[] | null
type ValueObject<V extends Value> = Record<string, V | undefined>
type ResponsiveValue<V extends Value> = V | ValueObject<V>

const isValue = <V extends Value>(object: ResponsiveValue<V>): object is V => !isObject(object)
const isValueObject = <V extends Value>(object: ResponsiveValue<V>): object is ValueObject<V> => isObject(object)
const isObject = (value: unknown): value is Record<string, unknown> => typeof value === 'object' && !Array.isArray(value)

const responsiveSome = <V extends Value>(value: ResponsiveValue<V>, callbackfn: (value: V) => boolean) => {
 if (isValue(value)) {
 return callbackfn(value)
 } else {
 // BUG in 4.3: value should have type ValueObject<V>, but has ValueObject<V> | Value
 return Object.values(value).some(v => (typeof v === 'undefined' ? false : callbackfn(v)))
 }
}

Output

"use strict";
const isValue = (object) => !isObject(object);
const isValueObject = (object) => isObject(object);
const isObject = (value) => typeof value === 'object' && !Array.isArray(value);
const responsiveSome = (value, callbackfn) => {
 if (isValue(value)) {
 return callbackfn(value);
 }
 else {
 // BUG in 4.3: value should have type ValueObject<V>, but has ValueObject<V> | Value
 return Object.values(value).some(v => (typeof v === 'undefined' ? false : callbackfn(v)));
 }
};

Compiler Options

{
 "compilerOptions": {
 "noImplicitAny": true,
 "strictNullChecks": true,
 "strictFunctionTypes": true,
 "strictPropertyInitialization": true,
 "strictBindCallApply": true,
 "noImplicitThis": true,
 "noImplicitReturns": true,
 "alwaysStrict": true,
 "esModuleInterop": true,
 "declaration": true,
 "experimentalDecorators": true,
 "emitDecoratorMetadata": true,
 "target": "ES2017",
 "jsx": "react",
 "module": "ESNext",
 "moduleResolution": "node"
 }
}

Playground Link: Provided

[thw0rted]

I found a regression that I think might be the same one. (If not I can certainly open a new ticket?)

Playground example

abstract class TwoGeneric<T, U> {
 public abstract readonly t: T;

 protected abstract _u: U;
 public get u(): U { return this._u; }
 public set u(val: U) { this._u = val; }
}

class Child1 extends TwoGeneric<number, boolean> {
 public readonly t = 3;
 protected _u = false;
}

class Child2 extends TwoGeneric<string, boolean> {
 public readonly t = "Hi";
 protected _u = false;
}


declare const x: TwoGeneric<any, any>;

if (x instanceof Child1) {
 x.u = true;
}
if (x instanceof Child2) {
 x.u = true;
}

if (x instanceof Child1 || x instanceof Child2) {
 x.u = true; // Type 'boolean' is not assignable to type 'U'. 'U' could be instantiated with an arbitrary type which could be unrelated to 'boolean'.(2322)
}

Note that this works without errors in 4.2.x but fails in 4.3.x due to the "improved" narrowing.

The two standalone type-narrowing checks work, but the narrowed union fails. Inside the || conditional, Intellisense hints that x is Child1 | Child2. The type of x.u is the same for both, but it still fails with the error message in the comment.