Tooltip for function overloaded to mimic variadic types infers wrong overload when called with trailing comma

[krryan]

TypeScript Version: 2.7.0-dev.20180418

Search Terms: Intellisense overload, tooltip overload

Code

function test<A>(a: A): true;
function test<A, B>(a: A, b: B): false;
function test<T>(...values: T[]): boolean {
    return values.length === 1;
}

declare function assertTrue(truth: true): void;

const noComma = test( // test<string>(a: string): true
    'foo'
)
assertTrue(noComma);

const withComma = test( // test<string, {}>(a: string, b: {}): false, but withComma: true
    'foo',
);
assertTrue(withComma);

assertTrue(test( // test<string, {}>(a: string, b: {}): false, but no error
    'foo',
));

Expected behavior:
The inferred version of test (as shown in hover-over tooltip) for noComma, withComma, and directly passed to assertTrue is the test<A>(a: A): true version.

Actual behavior:
The inferred version of test for the withComma and directly-passed versions is the test<A, B>(a: A, b: B): false, specifically test<string, {}>(a: string, b: {}): false.

Despite this, withComma has type true, and no error is reported for the call to assertTrue with it or when directly passed.

Playground Link: here

Related Issues: #7279

[mhegazy]

we use the trailing comma as an indication that the user is typing the function, and that the argument list is incomplete. it just happens that trailing commas are now allowed part of the language. we should limit this to the signature help and not in the quick info as well.

[mhegazy]

PRs appreciated.

[JoseLion]

Any news on this issue? The problem is affecting more than just the quick info tooltip. For example, if a lint tool uses the wrong inferred overload, it can cause an error/warning if that overload is marked as deprecated. I stumbled into precisely that scenario while using the .map(..) operator of RxJS, which has the following signature (at the time):

export function map<T, R>(project: (value: T, index: number) => R): OperatorFunction<T, R>;
/** @deprecated Use a closure instead of a `thisArg`. Signatures accepting a `thisArg` will be removed in v8. */
export function map<T, R, A>(project: (this: A, value: T, index: number) => R, thisArg: A): OperatorFunction<T, R>;

Of course, the deprecated API will be removed eventually, but until that happens, Linters checking for deprecated code can give us a hard time:

const source = from([1, 2, 3, 4, 5]);

source.pipe(map(val => val + 10)); // complaint

source.pipe(
  map( // non-complaint: the deprecated overload is inferred
    val => val + 10,
  ),
);

I can try to help with a PR, but it'd be great if someone could point me in the right direction as this would be my first time contributing to TypeScript's codebase 🙂

Thanks in advance!