Return type inference does not infer union

[AnyhowStep]

TypeScript Version: 3.5.1, 3.3.3

Search Terms:

return type, infer, union

Code

/**
 * + TS 3.5.1
 * + TS 3.3.3
 */
export interface CreateResult {
    contributors : (
        & {
            someType : string,
        }
        & {
            subObject : (
                | (
                    & {
                        someId : number,
                        prop0 : number,
                    }
                    & {
                        THIS_IS_REQUIRED_WHEN_SOME_ID_IS_SET : "BUT IT IS NOT SET",
                    }
                )
                | {
                    someId? : undefined,
                    prop0 : number,
                }
            ),
        }
    )[];
}

function foo (arg : { someType : string, subObject : { prop0 : number } }) {
    if (Math.random() > 0.5) {
        return arg;
    } else {
        const subObject = {
            someId : 0,
            prop0 : 0,
        };
        /*
            Expected and Actual are the same.
            {
                someType: string;
                subObject: {
                    someId: number;
                    prop0: number;
                };
            }
        */
        const result = {
            ...arg,
            subObject : {
                ...subObject,
            },
        };
        return result;
    }
}

/*
    Expected:
    | {
        someType: string;
        subObject: {
            prop0: number;
        };
    }
    | {
        someType: string;
        subObject: {
            someId: number,
            prop0: number;
        };
    }

    Actual:
    {
        someType: string;
        subObject: {
            prop0: number;
        };
    }
*/
const wtf = foo({
    someType : "",
    subObject : {
        prop0 : 0,
    }
});

/**
 * It is now possible for `wtf` to have `someId` be `number`,
 * but `THIS_IS_REQUIRED_WHEN_SOME_ID_IS_SET` is not set.
 */
const x : CreateResult["contributors"][number] = wtf;

Expected behavior:

wtf should be a union of types.

Actual behavior:

wtf is not a union of types.

Playground Link: Playground

Related Issues:

I'll keep searching but I couldn't find anything. There were a bunch with the same keywords but they seemed unrelated, focusing on literals and generics.

[AnyhowStep]

Smaller repro, foo() does not need to have arguments.

Playground

[AnyhowStep]

Interestingly enough, if you replace,

return arg;

with,

return {
    someType : "",
    subObject : {
        prop0 : 0,
    }
};

The inferred return type of foo() is correct, even though both statements return the same type.

[RyanCavanaugh]

This is normal subtype reduction - the type T | U when U is a subtype of T is reduced to T during most inference operations.

[AnyhowStep]

Facepalms
Right. That makes sense. I forgot about that.

It makes for unsound code in this case but soundness was never a goal.

[AnyhowStep]

Wait, that doesn't explain why changing the return statement to a different form makes it infer the union.

Both return arg; and return { /*properties*/ }; return the same type. One does not give the desired inferred return type. The other does.

Or is the key phrase here "most inference operations"?

And it just so happens that using a different kind of return statement changes the inference?

Pretty unintuitive, and it doesn't seem like I should rely on the behavior. I guess an explicit return type annotation is better in this case?

[jack-williams]

Wait, that doesn't explain why changing the return statement to a different form makes it infer the union.

Maybe due to object literal freshness?

[AnyhowStep]

You're probably right but I wonder if it was a conscious decision and why. It seems like a rather obscure rule.