Inferred return type of function is incorrect when one of the return types is a conditional type

[jespertheend]

Bug Report

🔎 Search Terms

ignored return type generic conditional

🕗 Version & Regression Information

• This is the behavior in every version I tried, and I reviewed the FAQ for entries about return

⏯ Playground Link

Playground link with relevant code

💻 Code

type Foo<T> = {
    template: T;
}

type Bar<T> = T extends boolean ? Foo<number> : Foo<string>;

type Baz<T extends boolean> = Bar<T> extends infer InferredFoo
    ? InferredFoo extends Foo<any>
        ? "yes"
        : never
    : never;

function test<T extends boolean>(opts: T) {
    const x = false;

    // If you comment the line below, this function starts
    // returning Baz<T> as expected, which in turn makes `result`
    // have the type "yes".
    // The if statement below should have no impact to the
    // return type of the function, other than adding `| null`.
    // After all, you can force the return type of the function
    // to be `Baz<T> | null` and it still works fine.
    if (x) return null;

    return {} as Baz<T>;
}

const result = test(true);

🙁 Actual behavior

result has type null

🙂 Expected behavior

result should have type null | "yes"

[RyanCavanaugh]

What's the intent of writing Bar<T> extends infer InferredFoo ?

Anyway this is super weird. Possible red herrings removed:

type Foo<T> = {
    template: T;
}

type Bar<T> = T extends string ? Foo<number> : Foo<string>;

type Baz<T extends string> = Bar<T> extends infer InferredFoo
    ? InferredFoo extends Foo<unknown>
        ? "yes"
        : never
    : never;

function test<T extends string>(opts: T) {
    if (Math.random() > 0.5) {
        return null;
    }
    return {} as Baz<T>;
}

// null
const result = test("");

contrast with

type Foo<T> = {
    template: T;
}

type Bar<T> = T extends string ? Foo<number> : Foo<string>;

type Baz<T extends string> = Bar<T> extends infer InferredFoo
    ? InferredFoo extends Foo<unknown>
        ? "yes"
        : "no_1" // <- never to no_1
    : "no_2"; // <- never to no_2

function test<T extends string>(opts: T) {
    if (Math.random() > 0.5) {
        return null;
    }
    return {} as Baz<T>;
}

// result: null | "yes"
const result = test("");

[jespertheend]

What's the intent of writing Bar<T> extends infer InferredFoo ?

That was a thing I did to make a long variable and template I had shorter, so I could reuse it a bunch of times without having to type it out all the way. Though I see now that this wasn't actually necessary because I'm only using InferredFoo once in my real world code as well.