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.

[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
Compiler Options
Playground Link: Provided

@andrewbranch this bug still happens in 4.5.4. Should I create a separate issue for this?

[andrewbranch]

@fabb the generics in your type guards aren’t useful as far as I can tell. Try this.

[fabb]

True, thanks!
It’s still a regression, but maybe there really is no use case that cannot be transformed like this.