Always fill in type arguments in pickLongestCandidateSignature (Fixes #19854)

Author: Andy Hanson

src/compiler/checker.ts

@@ -3199,7 +3199,7 @@ namespace ts {
             if ((symbol as TransientSymbol).syntheticLiteralTypeOrigin) {
                 const stringValue = (symbol as TransientSymbol).syntheticLiteralTypeOrigin.value;
                 if (!isIdentifierText(stringValue, compilerOptions.target)) {
-                    return `"${escapeString(stringValue, CharacterCodes.doubleQuote)}"`;
+                    return '"' + escapeString(stringValue, CharacterCodes.doubleQuote) + '"';
                 }
             }
             return symbolName(symbol);
@@ -5562,9 +5562,9 @@ namespace ts {
         /**
          * Gets the symbolic name for a late-bound member from its type.
          */
-        function getLateBoundNameFromType(type: LiteralType | UniqueESSymbolType) {
+        function getLateBoundNameFromType(type: LiteralType | UniqueESSymbolType): __String | undefined {
             if (type.flags & TypeFlags.UniqueESSymbol) {
-                return `__@${type.symbol.escapedName}@${getSymbolId(type.symbol)}` as __String;
+                return "__@" + type.symbol.escapedName + "@" + getSymbolId(type.symbol) as __String;
             }
             if (type.flags & TypeFlags.StringOrNumberLiteral) {
                 return escapeLeadingUnderscores("" + (<LiteralType>type).value);
@@ -17176,21 +17176,22 @@ namespace ts {
             const candidate = candidates[bestIndex];
 
             const { typeParameters } = candidate;
-            if (typeParameters && callLikeExpressionMayHaveTypeArguments(node) && node.typeArguments) {
-                const typeArguments = node.typeArguments.map(getTypeOfNode);
-                while (typeArguments.length > typeParameters.length) {
-                    typeArguments.pop();
-                }
-                while (typeArguments.length < typeParameters.length) {
-                    typeArguments.push(getDefaultTypeArgumentType(isInJavaScriptFile(node)));
-                }
+            if (!typeParameters) {
+                return candidate;
+            }
 
-                const instantiated = createSignatureInstantiation(candidate, typeArguments);
-                candidates[bestIndex] = instantiated;
-                return instantiated;
+            const typeArgumentNodes: ReadonlyArray<TypeNode> = callLikeExpressionMayHaveTypeArguments(node) ? node.typeArguments || emptyArray : emptyArray;
+            const typeArguments = typeArgumentNodes.map(getTypeOfNode);
+            while (typeArguments.length > typeParameters.length) {
+                typeArguments.pop();
+            }
+            while (typeArguments.length < typeParameters.length) {
+                typeArguments.push(getDefaultTypeArgumentType(isInJavaScriptFile(node)));
             }
 
-            return candidate;
+            const instantiated = createSignatureInstantiation(candidate, typeArguments);
+            candidates[bestIndex] = instantiated;
+            return instantiated;
         }
 
         function getLongestCandidateIndex(candidates: ReadonlyArray<Signature>, argsCount: number): number {

src/harness/harness.ts

@@ -37,7 +37,7 @@ namespace assert {
         assert(!expr, msg);
     }
     export function equal<T>(a: T, b: T, msg = "Expected values to be equal."): void {
-        assert(a === b, msg);
+        assert(a === b, () => `${msg} Expected:\n${stringify(a)}\nActual:\n${stringify(b)}`);
     }
     export function notEqual<T>(a: T, b: T, msg = "Expected values to not be equal."): void {
         assert(a !== b, msg);
@@ -49,7 +49,7 @@ namespace assert {
         assert(x === undefined, msg);
     }
     export function deepEqual<T>(a: T, b: T, msg?: string): void {
-        assert(isDeepEqual(a, b), msg || (() => `Expected values to be deeply equal:\nExpected:\n${JSON.stringify(a, undefined, 4)}\nActual:\n${JSON.stringify(b, undefined, 4)}`));
+        assert(isDeepEqual(a, b), msg || (() => `Expected values to be deeply equal:\nExpected:\n${stringify(a)}\nActual:\n${stringify(b)}`));
     }
     export function lengthOf(a: ReadonlyArray<{}>, length: number, msg = "Expected length to match."): void {
         assert(a.length === length, msg);
@@ -76,6 +76,10 @@ namespace assert {
         const bKeys = Object.keys(b).sort();
         return aKeys.length === bKeys.length && aKeys.every((key, i) => bKeys[i] === key && isDeepEqual((a as any)[key], (b as any)[key]));
     }
+
+    function stringify(value: {} | null | undefined): string {
+        return JSON.stringify(value, undefined, 4);
+    }
 }
 declare var __dirname: string; // Node-specific
 var global: NodeJS.Global = <any>Function("return this").call(undefined);

tests/cases/fourslash/quickInfo_errorSignatureFillsInTypeParameter.ts

@@ -0,0 +1,6 @@
+/// <reference path='fourslash.ts'/>
+
+////declare function f<T>(x: number): T;
+////const x/**/ = f();
+
+verify.quickInfoAt("", "const x: {}");