Editor changes overload resolution based on syntax about typescript HOT 6 CLOSED

I gave this a try with a different syntax for overloads:

declare function bar(
  ...args: [arg0: string, arg1: number, arg2: boolean] | [arg0: number, arg1: boolean, arg2: string] | [arg0: boolean, arg1: string, arg2: number]
): void;

This example is even worse. The editor correctly finds the 3 overloads, but bar(5, and bar(5, ) both fail to resolve to the second overload.

from typescript.

The difference lies in how callIsIncomplete gets computed in both scenarios:
https://github.dev/microsoft/TypeScript/blob/0b71b81d7d053a3acd379ff49550b3c67f9ce3cd/src/compiler/checker.ts#L33830-L33831
and how, based on that, the version without parenthesis returns true from hasCorrectArity:
https://github.dev/microsoft/TypeScript/blob/0b71b81d7d053a3acd379ff49550b3c67f9ce3cd/src/compiler/checker.ts#L33845-L33849

from typescript.

I don't think it's really possible to define what the "correct" overload is for an argument set that doesn't match anything. When the parens are still open it makes sense to pretend the future params might be there, but when it's closed, well, who can say what kind of mistake you're making. For example, if there's an overload of one parameter of type "foo" and you wrote func("oo") it seems like we should show you "foo" rather than some other possible overload

from typescript.

@RyanCavanaugh not really sure I agree with you. "oo" doesn't match "foo", so why would you show me "foo"?

Overload matching should be best effort matching, no?

In my example, the argument list isn't done, because the comma is indicating I intend to add more arguments.

Not adding another argument is a syntax error. Removing the comma is a compiler error. In either of these choices, it's an invalid call. Why complicate things by not even telling me what the next argument should be?

from typescript.

In cases where you have trailing commas in an argument list, you'd have a compiler error if you couldn't find the right overload, so I'd agree here that it wouldn't matter which overload you show.

declare function foo(x: number): void;
declare function foo(x: "foo"): void;

foo(
  "oo",  // error: No overload matches this call.
)

But this is a specifically talking about functions with one parameter.

The main issue I'm trying to outline in my example is that there are multiple parameters, with a correct first argument, yet the overload is not resolved/narrowed.

from typescript.

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

from typescript.