@@ -320,6 +320,7 @@ import {
320
320
getJSDocParameterTags,
321
321
getJSDocRoot,
322
322
getJSDocSatisfiesExpressionType,
323
+ getJSDocSpecializeTag,
323
324
getJSDocTags,
324
325
getJSDocThisTag,
325
326
getJSDocType,
@@ -827,7 +828,6 @@ import {
827
828
JsxFlags,
828
829
JsxFragment,
829
830
JsxNamespacedName,
830
- JsxOpeningElement,
831
831
JsxOpeningFragment,
832
832
JsxOpeningLikeElement,
833
833
JsxReferenceKind,
@@ -34636,15 +34636,34 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
34636
34636
return checkIndexedAccessIndexType(getFlowTypeOfAccessExpression(node, getNodeLinks(node).resolvedSymbol, indexedAccessType, indexExpression, checkMode), node);
34637
34637
}
34638
34638
34639
- function callLikeExpressionMayHaveTypeArguments(node: CallLikeExpression): node is CallExpression | NewExpression | TaggedTemplateExpression | JsxOpeningElement {
34639
+ function callLikeExpressionMayHaveTypeArguments(node: CallLikeExpression): node is CallExpression | NewExpression | TaggedTemplateExpression | JsxOpeningLikeElement {
34640
34640
return isCallOrNewExpression(node) || isTaggedTemplateExpression(node) || isJsxOpeningLikeElement(node);
34641
34641
}
34642
34642
34643
+ function getTypeArgumentsForCallLikeExpression(node: CallExpression | NewExpression | TaggedTemplateExpression | JsxOpeningLikeElement) {
34644
+ if (isSuperCall(node)) {
34645
+ return undefined;
34646
+ }
34647
+ if (isInJSFile(node)) {
34648
+ let { parent } = node;
34649
+ if (isJsxElement(parent)) {
34650
+ parent = parent.parent;
34651
+ }
34652
+ if (canHaveJSDoc(parent)) {
34653
+ const specializeTag = getJSDocSpecializeTag(parent);
34654
+ if (specializeTag) {
34655
+ return specializeTag.typeArguments;
34656
+ }
34657
+ }
34658
+ }
34659
+ return node.typeArguments;
34660
+ }
34661
+
34643
34662
function resolveUntypedCall(node: CallLikeExpression): Signature {
34644
34663
if (callLikeExpressionMayHaveTypeArguments(node)) {
34645
34664
// Check type arguments even though we will give an error that untyped calls may not accept type arguments.
34646
34665
// This gets us diagnostics for the type arguments and marks them as referenced.
34647
- forEach(node.typeArguments , checkSourceElement);
34666
+ forEach(getTypeArgumentsForCallLikeExpression( node) , checkSourceElement);
34648
34667
}
34649
34668
34650
34669
if (node.kind === SyntaxKind.TaggedTemplateExpression) {
@@ -35595,21 +35614,15 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
35595
35614
}
35596
35615
35597
35616
function resolveCall(node: CallLikeExpression, signatures: readonly Signature[], candidatesOutArray: Signature[] | undefined, checkMode: CheckMode, callChainFlags: SignatureFlags, headMessage?: DiagnosticMessage): Signature {
35598
- const isTaggedTemplate = node.kind === SyntaxKind.TaggedTemplateExpression;
35599
35617
const isDecorator = node.kind === SyntaxKind.Decorator;
35600
- const isJsxOpeningOrSelfClosingElement = isJsxOpeningLikeElement(node);
35601
35618
const isInstanceof = node.kind === SyntaxKind.BinaryExpression;
35602
35619
const reportErrors = !isInferencePartiallyBlocked && !candidatesOutArray;
35603
35620
35604
35621
let typeArguments: NodeArray<TypeNode> | undefined;
35605
35622
35606
- if (!isDecorator && !isInstanceof && !isSuperCall(node)) {
35607
- typeArguments = (node as CallExpression).typeArguments;
35608
-
35609
- // We already perform checking on the type arguments on the class declaration itself.
35610
- if (isTaggedTemplate || isJsxOpeningOrSelfClosingElement || (node as CallExpression).expression.kind !== SyntaxKind.SuperKeyword) {
35611
- forEach(typeArguments, checkSourceElement);
35612
- }
35623
+ if (callLikeExpressionMayHaveTypeArguments(node)) {
35624
+ typeArguments = getTypeArgumentsForCallLikeExpression(node);
35625
+ forEach(typeArguments, checkSourceElement);
35613
35626
}
35614
35627
35615
35628
const candidates = candidatesOutArray || [];
@@ -35781,7 +35794,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
35781
35794
diagnostics.add(getArgumentArityError(node, [candidateForArgumentArityError], args, headMessage));
35782
35795
}
35783
35796
else if (candidateForTypeArgumentError) {
35784
- checkTypeArguments(candidateForTypeArgumentError, (node as CallExpression | TaggedTemplateExpression | JsxOpeningLikeElement). typeArguments!, /*reportErrors*/ true, headMessage);
35797
+ checkTypeArguments(candidateForTypeArgumentError, typeArguments!, /*reportErrors*/ true, headMessage);
35785
35798
}
35786
35799
else {
35787
35800
const signaturesWithCorrectTypeArgumentArity = filter(signatures, s => hasCorrectTypeArgumentArity(s, typeArguments));
@@ -35995,7 +36008,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
35995
36008
return candidate;
35996
36009
}
35997
36010
35998
- const typeArgumentNodes: readonly TypeNode[] | undefined = callLikeExpressionMayHaveTypeArguments(node) ? node.typeArguments : undefined;
36011
+ const typeArgumentNodes: readonly TypeNode[] | undefined = callLikeExpressionMayHaveTypeArguments(node) ? getTypeArgumentsForCallLikeExpression( node) : undefined;
35999
36012
const instantiated = typeArgumentNodes
36000
36013
? createSignatureInstantiation(candidate, getTypeArgumentsFromNodes(typeArgumentNodes, typeParameters, isInJSFile(node)))
36001
36014
: inferSignatureInstantiationForOverloadFailure(node, typeParameters, candidate, args, checkMode);
@@ -36095,14 +36108,15 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
36095
36108
// that the user will not add any.
36096
36109
const callSignatures = getSignaturesOfType(apparentType, SignatureKind.Call);
36097
36110
const numConstructSignatures = getSignaturesOfType(apparentType, SignatureKind.Construct).length;
36111
+ const typeArguments = getTypeArgumentsForCallLikeExpression(node);
36098
36112
36099
36113
// TS 1.0 Spec: 4.12
36100
36114
// In an untyped function call no TypeArgs are permitted, Args can be any argument list, no contextual
36101
36115
// types are provided for the argument expressions, and the result is always of type Any.
36102
36116
if (isUntypedFunctionCall(funcType, apparentType, callSignatures.length, numConstructSignatures)) {
36103
36117
// The unknownType indicates that an error already occurred (and was reported). No
36104
36118
// need to report another error in this case.
36105
- if (!isErrorType(funcType) && node. typeArguments) {
36119
+ if (!isErrorType(funcType) && typeArguments) {
36106
36120
error(node, Diagnostics.Untyped_function_calls_may_not_accept_type_arguments);
36107
36121
}
36108
36122
return resolveUntypedCall(node);
@@ -36138,7 +36152,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
36138
36152
// use the resolvingSignature singleton to indicate that we deferred processing. This result will be
36139
36153
// propagated out and eventually turned into silentNeverType (a type that is assignable to anything and
36140
36154
// from which we never make inferences).
36141
- if (checkMode & CheckMode.SkipGenericFunctions && !node. typeArguments && callSignatures.some(isGenericFunctionReturningFunction)) {
36155
+ if (checkMode & CheckMode.SkipGenericFunctions && !typeArguments && callSignatures.some(isGenericFunctionReturningFunction)) {
36142
36156
skippedGenericFunction(node, checkMode);
36143
36157
return resolvingSignature;
36144
36158
}
@@ -36183,11 +36197,12 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
36183
36197
return resolveErrorCall(node);
36184
36198
}
36185
36199
36200
+ const typeArguments = getTypeArgumentsForCallLikeExpression(node);
36186
36201
// TS 1.0 spec: 4.11
36187
36202
// If expressionType is of type Any, Args can be any argument
36188
36203
// list and the result of the operation is of type Any.
36189
36204
if (isTypeAny(expressionType)) {
36190
- if (node. typeArguments) {
36205
+ if (typeArguments) {
36191
36206
error(node, Diagnostics.Untyped_function_calls_may_not_accept_type_arguments);
36192
36207
}
36193
36208
return resolveUntypedCall(node);
@@ -36552,9 +36567,10 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
36552
36567
const result = getIntrinsicAttributesTypeFromJsxOpeningLikeElement(node);
36553
36568
const fakeSignature = createSignatureForJSXIntrinsic(node, result);
36554
36569
checkTypeAssignableToAndOptionallyElaborate(checkExpressionWithContextualType(node.attributes, getEffectiveFirstArgumentForJsxSignature(fakeSignature, node), /*inferenceContext*/ undefined, CheckMode.Normal), result, node.tagName, node.attributes);
36555
- if (length(node.typeArguments)) {
36556
- forEach(node.typeArguments, checkSourceElement);
36557
- diagnostics.add(createDiagnosticForNodeArray(getSourceFileOfNode(node), node.typeArguments!, Diagnostics.Expected_0_type_arguments_but_got_1, 0, length(node.typeArguments)));
36570
+ const typeArguments = getTypeArgumentsForCallLikeExpression(node);
36571
+ if (length(typeArguments)) {
36572
+ forEach(typeArguments, checkSourceElement);
36573
+ diagnostics.add(createDiagnosticForNodeArray(getSourceFileOfNode(node), typeArguments!, Diagnostics.Expected_0_type_arguments_but_got_1, 0, length(typeArguments)));
36558
36574
}
36559
36575
return fakeSignature;
36560
36576
}
@@ -36810,7 +36826,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
36810
36826
* @returns On success, the expression's signature's return type. On failure, anyType.
36811
36827
*/
36812
36828
function checkCallExpression(node: CallExpression | NewExpression, checkMode?: CheckMode): Type {
36813
- checkGrammarTypeArguments(node, node.typeArguments );
36829
+ checkGrammarTypeArguments(node, getTypeArgumentsForCallLikeExpression( node) );
36814
36830
36815
36831
const signature = getResolvedSignature(node, /*candidatesOutArray*/ undefined, checkMode);
36816
36832
if (signature === resolvingSignature) {
@@ -37049,7 +37065,9 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
37049
37065
}
37050
37066
37051
37067
function checkTaggedTemplateExpression(node: TaggedTemplateExpression): Type {
37052
- if (!checkGrammarTaggedTemplateChain(node)) checkGrammarTypeArguments(node, node.typeArguments);
37068
+ if (!checkGrammarTaggedTemplateChain(node)) {
37069
+ checkGrammarTypeArguments(node, getTypeArgumentsForCallLikeExpression(node));
37070
+ }
37053
37071
if (languageVersion < LanguageFeatureMinimumTarget.TaggedTemplates) {
37054
37072
checkExternalEmitHelpers(node, ExternalEmitHelpers.MakeTemplateObject);
37055
37073
}
@@ -41595,15 +41613,15 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
41595
41613
checkDecorators(node);
41596
41614
}
41597
41615
41598
- function getEffectiveTypeArgumentAtIndex(node: TypeReferenceNode | ExpressionWithTypeArguments , typeParameters: readonly TypeParameter[], index: number): Type {
41616
+ function getEffectiveTypeArgumentAtIndex(node: TypeReferenceNode, typeParameters: readonly TypeParameter[], index: number): Type {
41599
41617
if (node.typeArguments && index < node.typeArguments.length) {
41600
41618
return getTypeFromTypeNode(node.typeArguments[index]);
41601
41619
}
41602
41620
return getEffectiveTypeArguments(node, typeParameters)[index];
41603
41621
}
41604
41622
41605
41623
function getEffectiveTypeArguments(node: TypeReferenceNode | ExpressionWithTypeArguments | NodeWithTypeArguments, typeParameters: readonly TypeParameter[]): Type[] {
41606
- return fillMissingTypeArguments(map(node.typeArguments! , getTypeFromTypeNode), typeParameters, getMinTypeArgumentCount(typeParameters), isInJSFile(node));
41624
+ return fillMissingTypeArguments(map(node.typeArguments || [] , getTypeFromTypeNode), typeParameters, getMinTypeArgumentCount(typeParameters), isInJSFile(node));
41607
41625
}
41608
41626
41609
41627
function checkTypeArgumentConstraints(node: TypeReferenceNode | ExpressionWithTypeArguments | NodeWithTypeArguments, typeParameters: readonly TypeParameter[]): boolean {
@@ -51341,7 +51359,7 @@ export function createTypeChecker(host: TypeCheckerHost): TypeChecker {
51341
51359
51342
51360
function checkGrammarJsxElement(node: JsxOpeningLikeElement) {
51343
51361
checkGrammarJsxName(node.tagName);
51344
- checkGrammarTypeArguments(node, node.typeArguments );
51362
+ checkGrammarTypeArguments(node, getTypeArgumentsForCallLikeExpression( node) );
51345
51363
const seen = new Map<__String, boolean>();
51346
51364
51347
51365
for (const attr of node.attributes.properties) {
0 commit comments