Improve isPossiblyTypeArgumentPosition

Author: Andy Hanson

src/services/completions.ts

@@ -1056,7 +1056,7 @@ namespace ts.Completions {
             const isImportType = isLiteralImportTypeNode(node);
             const isTypeLocation = insideJsDocTagTypeExpression || (isImportType && !(node as ImportTypeNode).isTypeOf) || isPartOfTypeNode(node.parent);
             const isRhsOfImportDeclaration = isInRightSideOfInternalImportEqualsDeclaration(node);
-            const allowTypeOrValue = isRhsOfImportDeclaration || (!isTypeLocation && isPossiblyTypeArgumentPosition(contextToken, sourceFile));
+            const allowTypeOrValue = isRhsOfImportDeclaration || (!isTypeLocation && isPossiblyTypeArgumentPosition(contextToken, sourceFile, typeChecker));
             if (isEntityName(node) || isImportType) {
                 let symbol = typeChecker.getSymbolAtLocation(node);
                 if (symbol) {
@@ -1265,7 +1265,7 @@ namespace ts.Completions {
 
         function filterGlobalCompletion(symbols: Symbol[]): void {
             const isTypeOnlyCompletion = insideJsDocTagTypeExpression || !isContextTokenValueLocation(contextToken) && (isPartOfTypeNode(location) || isContextTokenTypeLocation(contextToken));
-            const allowTypes = isTypeOnlyCompletion || !isContextTokenValueLocation(contextToken) && isPossiblyTypeArgumentPosition(contextToken, sourceFile);
+            const allowTypes = isTypeOnlyCompletion || !isContextTokenValueLocation(contextToken) && isPossiblyTypeArgumentPosition(contextToken, sourceFile, typeChecker);
             if (isTypeOnlyCompletion) keywordFilters = KeywordCompletionFilters.TypeKeywords;
 
             filterMutate(symbols, symbol => {

src/services/signatureHelp.ts

@@ -58,9 +58,7 @@ namespace ts.SignatureHelp {
             return candidates.length === 0 ? undefined : { candidates, resolvedSignature };
         }
         else {
-            const type = checker.getTypeAtLocation(invocation.called)!; // TODO: GH#18217
-            const signatures = isNewExpression(invocation.called.parent) ? type.getConstructSignatures() : type.getCallSignatures();
-            const candidates = signatures.filter(candidate => !!candidate.typeParameters && candidate.typeParameters.length >= argumentInfo.argumentCount);
+            const candidates = getPossibleGenericSignatures(invocation.called, argumentInfo.argumentCount, checker);
             return candidates.length === 0 ? undefined : { candidates, resolvedSignature: first(candidates) };
         }
     }
@@ -205,7 +203,7 @@ namespace ts.SignatureHelp {
             };
         }
         else {
-            const typeArgInfo = isPossiblyTypeArgumentPosition(node, sourceFile);
+            const typeArgInfo = getPossibleTypeArgumentsInfo(node, sourceFile);
             if (typeArgInfo) {
                 const { called, nTypeArguments } = typeArgInfo;
                 const invocation: Invocation = { kind: InvocationKind.TypeArgs, called };

src/services/utilities.ts

@@ -924,11 +924,23 @@ namespace ts {
         }
     }
 
+    export function isPossiblyTypeArgumentPosition(token: Node, sourceFile: SourceFile, checker: TypeChecker): boolean {
+        const info = getPossibleTypeArgumentsInfo(token, sourceFile);
+        return info !== undefined && getPossibleGenericSignatures(info.called, info.nTypeArguments, checker).length !== 0;
+    }
+
+    export function getPossibleGenericSignatures(called: Expression, typeArgumentCount: number, checker: TypeChecker): ReadonlyArray<Signature> {
+        const type = checker.getTypeAtLocation(called)!; // TODO: GH#18217
+        const signatures = isNewExpression(called.parent) ? type.getConstructSignatures() : type.getCallSignatures();
+        return signatures.filter(candidate => !!candidate.typeParameters && candidate.typeParameters.length >= typeArgumentCount);
+    }
+
     export interface PossibleTypeArgumentInfo {
         readonly called: Identifier;
         readonly nTypeArguments: number;
     }
-    export function isPossiblyTypeArgumentPosition(tokenIn: Node, sourceFile: SourceFile): PossibleTypeArgumentInfo | undefined {
+    // Get info for an expression like `f <` that may be the start of type arguments.
+    export function getPossibleTypeArgumentsInfo(tokenIn: Node, sourceFile: SourceFile): PossibleTypeArgumentInfo | undefined {
         let token: Node | undefined = tokenIn;
         // This function determines if the node could be type argument position
         // Since during editing, when type argument list is not complete,

tests/cases/fourslash/completionsIsPossiblyTypeArgumentPosition.ts

@@ -0,0 +1,16 @@
+/// <reference path="fourslash.ts" />
+
+////const x = 0;
+////type T = number;
+////function f(x: number) {}
+////function g<T>(x: T) {}
+
+////x + /*0*/
+////x < /*1*/
+////f < /*2*/
+////g < /*3*/
+
+verify.completions(
+    { marker: ["0", "1", "2"], includes: "x", excludes: "T" },
+    { marker: "3", includes: ["x", "T"] },
+);