Use isPossiblyTypeArgumentPosition and support new expressions

Author: Andy Hanson

src/services/signatureHelp.ts

@@ -59,7 +59,8 @@ namespace ts.SignatureHelp {
         }
         else {
             const type = checker.getTypeAtLocation(invocation.called);
-            const candidates = type.getCallSignatures().filter(candidate => !!candidate.typeParameters && candidate.typeParameters.length >= argumentInfo.argumentCount);
+            const signatures = isNewExpression(invocation.called.parent) ? type.getConstructSignatures() : type.getCallSignatures();
+            const candidates = signatures.filter(candidate => !!candidate.typeParameters && candidate.typeParameters.length >= argumentInfo.argumentCount);
             return candidates.length === 0 ? undefined : { candidates, resolvedSignature: first(candidates) };
         }
     }
@@ -204,27 +205,17 @@ namespace ts.SignatureHelp {
                 argumentCount: 1
             };
         }
-        else if (isBinaryExpression(node.parent)) {
-            const info = getInfoForBinaryExpressionResemblingTypeArguments(node.parent);
-            if (!info) return undefined;
-            const { called, nTypeArguments } = info;
-            const argumentsSpan = createTextSpanFromBounds(called.getStart(sourceFile), node.end);
-            return { kind: ArgumentListKind.TypeArguments, invocation: { kind: InvocationKind.TypeArgs, called }, argumentsSpan, argumentIndex: nTypeArguments - 1, argumentCount: nTypeArguments };
+        else {
+            const typeArgInfo = isPossiblyTypeArgumentPosition(node, sourceFile);
+            if (typeArgInfo) {
+                const { called, nTypeArguments } = typeArgInfo;
+                const invocation: Invocation = { kind: InvocationKind.TypeArgs, called };
+                const argumentsSpan = createTextSpanFromBounds(called.getStart(sourceFile), node.end);
+                return { kind: ArgumentListKind.TypeArguments, invocation, argumentsSpan, argumentIndex: nTypeArguments, argumentCount: nTypeArguments + 1 };
+            }
         }
-        return undefined;
-    }
 
-    /** Code like `f<T, U,` will be parsed as a series of `BinaryExpression`s. */
-    function getInfoForBinaryExpressionResemblingTypeArguments(bin: BinaryExpression): { readonly called: Expression, readonly nTypeArguments: number } | undefined {
-        switch (bin.operatorToken.kind) {
-            case SyntaxKind.LessThanToken:
-                return { called: bin.left, nTypeArguments: 1 };
-            case SyntaxKind.CommaToken:
-                const left = isBinaryExpression(bin.left) ? getInfoForBinaryExpressionResemblingTypeArguments(bin.left) : undefined;
-                return left && { called: left.called, nTypeArguments: left.nTypeArguments + 1 };
-            default:
-                return undefined;
-        }
+        return undefined;
     }
 
     function getArgumentIndex(argumentsList: Node, node: Node) {

src/services/utilities.ts

@@ -912,21 +912,26 @@ namespace ts {
         }
     }
 
-    export function isPossiblyTypeArgumentPosition(token: Node, sourceFile: SourceFile) {
+    export interface PossibleTypeArgumentInfo {
+        readonly called: Identifier;
+        readonly nTypeArguments: number;
+    }
+    export function isPossiblyTypeArgumentPosition(token: Node, sourceFile: SourceFile): PossibleTypeArgumentInfo | undefined {
         // This function determines if the node could be type argument position
         // Since during editing, when type argument list is not complete,
         // the tree could be of any shape depending on the tokens parsed before current node,
         // scanning of the previous identifier followed by "<" before current node would give us better result
         // Note that we also balance out the already provided type arguments, arrays, object literals while doing so
         let remainingLessThanTokens = 0;
+        let nTypeArguments = 0;
         while (token) {
             switch (token.kind) {
                 case SyntaxKind.LessThanToken:
                     // Found the beginning of the generic argument expression
                     token = findPrecedingToken(token.getFullStart(), sourceFile);
-                    const tokenIsIdentifier = token && isIdentifier(token);
-                    if (!remainingLessThanTokens || !tokenIsIdentifier) {
-                        return tokenIsIdentifier;
+                    if (!token || !isIdentifier(token)) return undefined;
+                    if (!remainingLessThanTokens) {
+                        return { called: token, nTypeArguments };
                     }
                     remainingLessThanTokens--;
                     break;
@@ -947,25 +952,28 @@ namespace ts {
                     // This can be object type, skip until we find the matching open brace token
                     // Skip until the matching open brace token
                     token = findPrecedingMatchingToken(token, SyntaxKind.OpenBraceToken, sourceFile);
-                    if (!token) return false;
+                    if (!token) return undefined;
                     break;
 
                 case SyntaxKind.CloseParenToken:
                     // This can be object type, skip until we find the matching open brace token
                     // Skip until the matching open brace token
                     token = findPrecedingMatchingToken(token, SyntaxKind.OpenParenToken, sourceFile);
-                    if (!token) return false;
+                    if (!token) return undefined;
                     break;
 
                 case SyntaxKind.CloseBracketToken:
                     // This can be object type, skip until we find the matching open brace token
                     // Skip until the matching open brace token
                     token = findPrecedingMatchingToken(token, SyntaxKind.OpenBracketToken, sourceFile);
-                    if (!token) return false;
+                    if (!token) return undefined;
                     break;
 
                 // Valid tokens in a type name. Skip.
                 case SyntaxKind.CommaToken:
+                    nTypeArguments++;
+                    break;
+
                 case SyntaxKind.EqualsGreaterThanToken:
 
                 case SyntaxKind.Identifier:
@@ -989,13 +997,13 @@ namespace ts {
                     }
 
                     // Invalid token in type
-                    return false;
+                    return undefined;
             }
 
             token = findPrecedingToken(token.getFullStart(), sourceFile);
         }
 
-        return false;
+        return undefined;
     }
 
     /**

tests/cases/fourslash/signatureHelpTypeArguments.ts

@@ -4,29 +4,59 @@
 ////declare function f<T extends number>(): void;
 ////declare function f<T, U>(): void;
 ////declare function f<T, U, V extends string>(): void;
-////f</*0*/;
-////f<number, /*1*/;
-////f<number, string, /*2*/;
+////f</*f0*/;
+////f<number, /*f1*/;
+////f<number, string, /*f2*/;
+////
+////declare const C: {
+////    new<T extends number>(): void;
+////    new<T, U>(): void;
+////    new<T, U, V extends string>(): void;
+////};
+////new C</*C0*/;
+////new C<number, /*C1*/;
+////new C<number, string, /*C2*/;
 
 verify.signatureHelp(
     {
-        marker: "0",
+        marker: "f0",
         overloadsCount: 3,
         text: "f<T extends number>(): void",
         parameterName: "T",
         parameterSpan: "T extends number",
     },
     {
-        marker: "1",
+        marker: "f1",
         overloadsCount: 2,
         text: "f<T, U>(): void",
         parameterName: "U",
         parameterSpan: "U",
     },
     {
-        marker: "2",
+        marker: "f2",
         text: "f<T, U, V extends string>(): void",
         parameterName: "V",
         parameterSpan: "V extends string",
     },
+
+    {
+        marker: "C0",
+        overloadsCount: 3,
+        text: "C<T extends number>(): void",
+        parameterName: "T",
+        parameterSpan: "T extends number",
+    },
+    {
+        marker: "C1",
+        overloadsCount: 2,
+        text: "C<T, U>(): void",
+        parameterName: "U",
+        parameterSpan: "U",
+    },
+    {
+        marker: "C2",
+        text: "C<T, U, V extends string>(): void",
+        parameterName: "V",
+        parameterSpan: "V extends string",
+    },
 );