Compiler fails to infer type in overloaded functions

[boris-kolar]

TypeScript Version: 3.6.3
Search Terms: overload overloaded infer type flow

Code

function foo(): void
function foo(a: string, b: string): void
function foo(a?: string, b?: string): void {
    if (!a) return
    console.log(a.length + b.length)
}

Expected behavior:
The code compiles (the compiler deduces b != null from the set of possible overloads)

Actual behavior:
bug.ts:5:28 - error TS2532: Object is possibly 'undefined'.

Playground Link:
https://www.typescriptlang.org/play/#code/GYVwdgxgLglg9mABMOcAUBKAXIgbnGAEwChRJYFlU0BDHAZygCcYwBzAGkQCMHnW22PARJlo8JCnQ0A-Hxbsu3OYkYLBOfEUQBvYogOIYwRGgCENDIiYBTKCCZh9hiAnpwANjYB0HuG1pfG3YoAAtEAGoeIJDQjGIAXyA

Related Issues: N/A

[RyanCavanaugh]

Duplicate #14515

[AnyhowStep]

Overloads are a real pain in the butt, honestly.
Often times, if you're not dealing with generic functions and the overload does not affect the return type, I find that you're better off using rest args on tuple types.

function foo(...args : []|[number, number]): void {
    if (args.length == 0) return;
    const [a, b] = args;
    console.log(a.length + b.length);
}

foo(); //OK
foo(1,2); //OK
foo(1); //Error

I'm on mobile now, so I might have made a mistake but the above should work

[AnyhowStep]

Another example I posted on Gitter earlier on,

interface Data {
    someUsefulPieceOfInfo : string
}
function callback (...args : [Error]|[null|undefined, Data]) {
    if (args[0] == undefined) {
        console.log(args[1].someUsefulPieceOfInfo);
    } else {
        console.error(args[0].message);
    }
}

callback(new Error("blah"));
callback(undefined, { someUsefulPieceOfInfo : "Hello, world" });

Playground

[typescript-bot]

This issue has been marked as a 'Duplicate' and has seen no recent activity. It has been automatically closed for house-keeping purposes.

[afreix]

@AnyhowStep in response to #33704 (comment)

Is there any workaround for when you are using generics?

export function allLoaded<TData1>(
  responses: [Response<TData1>]
): responses is [ResponseSuccessful<TData1>];
export function allLoaded<TData1, TData2>(
  responses: [Response<TData1>, Response<TData2>]
): responses is [ResponseSuccessful<TData1>, ResponseSuccessful<TData2>];
export function allLoaded(responses: Response<any>[]) {
  return responses.every(isLoaded);
}

// Type Guard
export function isLoaded<TData>(
  response: Response<TData>
): response is ResponseSuccessful {
  return response.status === QueryStatus.Success;
}

I'd like be able to define my overloads like above and be able to call allLoaded with a parameter of type [Response<TData1>] | [Response<TData1>, Response<TData2>]

[AnyhowStep]

Seems like the same pattern as Promise.all()

See, #33707