typescript-eslint · JoshuaKGoldberg · Feb 23, 2023 · Jul 26, 2022 · Jul 26, 2022 · Feb 5, 2023
diff --git a/packages/ast-spec/src/expression/CallExpression/spec.ts b/packages/ast-spec/src/expression/CallExpression/spec.ts
@@ -8,6 +8,6 @@ export interface CallExpression extends BaseNode {
   type: AST_NODE_TYPES.CallExpression;
   callee: LeftHandSideExpression;
   arguments: CallExpressionArgument[];
-  typeParameters?: TSTypeParameterInstantiation;
+  typeArguments?: TSTypeParameterInstantiation;
   optional: boolean;
 }
diff --git a/packages/ast-spec/src/expression/NewExpression/spec.ts b/packages/ast-spec/src/expression/NewExpression/spec.ts
@@ -8,5 +8,5 @@ export interface NewExpression extends BaseNode {
   type: AST_NODE_TYPES.NewExpression;
   callee: LeftHandSideExpression;
   arguments: CallExpressionArgument[];
-  typeParameters?: TSTypeParameterInstantiation;
+  typeArguments?: TSTypeParameterInstantiation;
 }
diff --git a/packages/ast-spec/src/expression/TaggedTemplateExpression/spec.ts b/packages/ast-spec/src/expression/TaggedTemplateExpression/spec.ts
@@ -6,7 +6,7 @@ import type { TemplateLiteral } from '../TemplateLiteral/spec';
 
 export interface TaggedTemplateExpression extends BaseNode {
   type: AST_NODE_TYPES.TaggedTemplateExpression;
-  typeParameters?: TSTypeParameterInstantiation;
+  typeArguments?: TSTypeParameterInstantiation;
   tag: LeftHandSideExpression;
   quasi: TemplateLiteral;
 }
diff --git a/packages/ast-spec/src/jsx/JSXOpeningElement/spec.ts b/packages/ast-spec/src/jsx/JSXOpeningElement/spec.ts
@@ -7,7 +7,7 @@ import type { JSXSpreadAttribute } from '../JSXSpreadAttribute/spec';
 
 export interface JSXOpeningElement extends BaseNode {
   type: AST_NODE_TYPES.JSXOpeningElement;
-  typeParameters?: TSTypeParameterInstantiation;
+  typeArguments?: TSTypeParameterInstantiation;
   selfClosing: boolean;
   name: JSXTagNameExpression;
   attributes: (JSXAttribute | JSXSpreadAttribute)[];

diff --git a/packages/ast-spec/src/type/TSImportType/spec.ts b/packages/ast-spec/src/type/TSImportType/spec.ts
@@ -8,5 +8,5 @@ export interface TSImportType extends BaseNode {
   type: AST_NODE_TYPES.TSImportType;
   argument: TypeNode;
   qualifier: EntityName | null;
-  typeParameters: TSTypeParameterInstantiation | null;
+  typeArguments: TSTypeParameterInstantiation | null;
 }
diff --git a/packages/ast-spec/src/type/TSTypeQuery/spec.ts b/packages/ast-spec/src/type/TSTypeQuery/spec.ts
@@ -7,5 +7,5 @@ import type { TSImportType } from '../TSImportType/spec';
 export interface TSTypeQuery extends BaseNode {
   type: AST_NODE_TYPES.TSTypeQuery;
   exprName: EntityName | TSImportType;
-  typeParameters?: TSTypeParameterInstantiation;
+  typeArguments?: TSTypeParameterInstantiation;
 }
diff --git a/packages/ast-spec/src/type/TSTypeReference/spec.ts b/packages/ast-spec/src/type/TSTypeReference/spec.ts
@@ -5,6 +5,6 @@ import type { EntityName } from '../../unions/EntityName';
 
 export interface TSTypeReference extends BaseNode {
   type: AST_NODE_TYPES.TSTypeReference;
+  typeArguments?: TSTypeParameterInstantiation;
   typeName: EntityName;
-  typeParameters?: TSTypeParameterInstantiation;
 }
diff --git a/packages/eslint-plugin/src/rules/array-type.ts b/packages/eslint-plugin/src/rules/array-type.ts
@@ -32,14 +32,14 @@ function isSimpleType(node: TSESTree.Node): boolean {
         node.typeName.type === AST_NODE_TYPES.Identifier &&
         node.typeName.name === 'Array'
       ) {
-        if (!node.typeParameters) {
+        if (!node.typeArguments) {
           return true;
         }
-        if (node.typeParameters.params.length === 1) {
-          return isSimpleType(node.typeParameters.params[0]);
+        if (node.typeArguments.params.length === 1) {
+          return isSimpleType(node.typeArguments.params[0]);
         }
       } else {
-        if (node.typeParameters) {
+        if (node.typeArguments) {
           return false;
         }
         return isSimpleType(node.typeName);
@@ -219,7 +219,7 @@ export default util.createRule<Options, MessageIds>({
         }
 
         const readonlyPrefix = isReadonlyArrayType ? 'readonly ' : '';
-        const typeParams = node.typeParameters?.params;
+        const typeParams = node.typeArguments?.params;
         const messageId =
           currentOption === 'array'
             ? 'errorStringArray'

diff --git a/packages/eslint-plugin/src/rules/ban-types.ts b/packages/eslint-plugin/src/rules/ban-types.ts
@@ -227,7 +227,7 @@ export default util.createRule<Options, MessageIds>({
       TSTypeReference(node): void {
         checkBannedTypes(node.typeName);
 
-        if (node.typeParameters) {
+        if (node.typeArguments) {
           checkBannedTypes(node);
         }
       },

diff --git a/packages/eslint-plugin/src/rules/consistent-generic-constructors.ts b/packages/eslint-plugin/src/rules/consistent-generic-constructors.ts
@@ -58,10 +58,10 @@ export default createRule<Options, MessageIds>({
           return;
         }
         if (mode === 'type-annotation') {
-          if (!lhs && rhs.typeParameters) {
-            const { typeParameters, callee } = rhs;
+          if (!lhs && rhs.typeArguments) {
+            const { typeArguments, callee } = rhs;
             const typeAnnotation =
-              sourceCode.getText(callee) + sourceCode.getText(typeParameters);
+              sourceCode.getText(callee) + sourceCode.getText(typeArguments);
             context.report({
               node,
               messageId: 'preferTypeAnnotation',
@@ -80,7 +80,7 @@ export default createRule<Options, MessageIds>({
                   return sourceCode.getTokenAfter(node.key)!;
                 }
                 return [
-                  fixer.remove(typeParameters),
+                  fixer.remove(typeArguments),
                   fixer.insertTextAfter(
                     getIDToAttachAnnotation(),
                     ': ' + typeAnnotation,
@@ -92,14 +92,14 @@ export default createRule<Options, MessageIds>({
           return;
         }
         if (mode === 'constructor') {
-          if (lhs?.typeParameters && !rhs.typeParameters) {
+          if (lhs?.typeArguments && !rhs.typeArguments) {
             const hasParens =
               sourceCode.getTokenAfter(rhs.callee)?.value === '(';
             const extraComments = new Set(
               sourceCode.getCommentsInside(lhs.parent),
             );
             sourceCode
-              .getCommentsInside(lhs.typeParameters)
+              .getCommentsInside(lhs.typeArguments)
               .forEach(c => extraComments.delete(c));
             context.report({
               node,
@@ -114,7 +114,7 @@ export default createRule<Options, MessageIds>({
                 }
                 yield fixer.insertTextAfter(
                   rhs.callee,
-                  sourceCode.getText(lhs.typeParameters),
+                  sourceCode.getText(lhs.typeArguments),
                 );
                 if (!hasParens) {
                   yield fixer.insertTextAfter(rhs.callee, '()');

diff --git a/packages/eslint-plugin/src/rules/consistent-indexed-object-style.ts b/packages/eslint-plugin/src/rules/consistent-indexed-object-style.ts
@@ -108,7 +108,7 @@ export default createRule<Options, MessageIds>({
             return;
           }
 
-          const params = node.typeParameters?.params;
+          const params = node.typeArguments?.params;
           if (params?.length !== 2) {
             return;
           }

diff --git a/packages/eslint-plugin/src/rules/func-call-spacing.ts b/packages/eslint-plugin/src/rules/func-call-spacing.ts
@@ -83,7 +83,7 @@ export default util.createRule<Options, MessageIds>({
 
       const closingParenToken = sourceCode.getLastToken(node)!;
       const lastCalleeTokenWithoutPossibleParens = sourceCode.getLastToken(
-        node.typeParameters ?? node.callee,
+        node.typeArguments ?? node.callee,
       )!;
       const openingParenToken = sourceCode.getFirstTokenBetween(
         lastCalleeTokenWithoutPossibleParens,

diff --git a/packages/eslint-plugin/src/rules/no-array-constructor.ts b/packages/eslint-plugin/src/rules/no-array-constructor.ts
@@ -31,7 +31,7 @@ export default util.createRule({
         node.arguments.length !== 1 &&
         node.callee.type === AST_NODE_TYPES.Identifier &&
         node.callee.name === 'Array' &&
-        !node.typeParameters &&
+        !node.typeArguments &&
         !util.isOptionalCallExpression(node)
       ) {
         context.report({

diff --git a/packages/eslint-plugin/src/rules/no-extra-parens.ts b/packages/eslint-plugin/src/rules/no-extra-parens.ts
@@ -80,7 +80,7 @@ export default util.createRule<Options, MessageIds>({
 
       if (
         node.arguments.length === 1 &&
-        node.typeParameters?.params.some(
+        node.typeArguments?.params.some(
           param =>
             param.type === AST_NODE_TYPES.TSImportType ||
             param.type === AST_NODE_TYPES.TSArrayType,

diff --git a/packages/eslint-plugin/src/rules/no-invalid-void-type.ts b/packages/eslint-plugin/src/rules/no-invalid-void-type.ts
@@ -156,9 +156,9 @@ export default util.createRule<[Options], MessageIds>({
           validUnionMembers.includes(member.type) ||
           // allows any T<..., void, ...> here, checked by checkGenericTypeArgument
           (member.type === AST_NODE_TYPES.TSTypeReference &&
-            member.typeParameters?.type ===
+            member.typeArguments?.type ===
               AST_NODE_TYPES.TSTypeParameterInstantiation &&
-            member.typeParameters?.params
+            member.typeArguments?.params
               .map(param => param.type)
               .includes(AST_NODE_TYPES.TSVoidKeyword)),
       );

diff --git a/packages/eslint-plugin/src/rules/no-type-alias.ts b/packages/eslint-plugin/src/rules/no-type-alias.ts
@@ -221,7 +221,7 @@ export default util.createRule<Options, MessageIds>({
     const isValidGeneric = (type: TypeWithLabel): boolean => {
       return (
         type.node.type === AST_NODE_TYPES.TSTypeReference &&
-        type.node.typeParameters !== undefined
+        type.node.typeArguments !== undefined
       );
     };
 

diff --git a/packages/eslint-plugin/src/rules/prefer-reduce-type-parameter.ts b/packages/eslint-plugin/src/rules/prefer-reduce-type-parameter.ts
@@ -86,7 +86,7 @@ export default util.createRule({
                 ]),
               ];
 
-              if (!callee.parent.typeParameters) {
+              if (!callee.parent.typeArguments) {
                 fixes.push(
                   fixer.insertTextAfter(
                     callee,

diff --git a/packages/scope-manager/src/referencer/ClassVisitor.ts b/packages/scope-manager/src/referencer/ClassVisitor.ts
@@ -325,8 +325,8 @@ class ClassVisitor extends Visitor {
           this.#referencer.currentScope().referenceDualValueType(entityName);
         }
 
-        if (node.typeAnnotation.typeParameters) {
-          this.visitType(node.typeAnnotation.typeParameters);
+        if (node.typeAnnotation.typeArguments) {
+          this.visitType(node.typeAnnotation.typeArguments);
         }
 
         // everything is handled now

diff --git a/packages/scope-manager/src/referencer/Referencer.ts b/packages/scope-manager/src/referencer/Referencer.ts
@@ -386,8 +386,8 @@ class Referencer extends Visitor {
   }
 
   protected CallExpression(node: TSESTree.CallExpression): void {
-    this.visitChildren(node, ['typeParameters']);
-    this.visitType(node.typeParameters);
+    this.visitChildren(node, ['typeArguments']);
+    this.visitType(node.typeArguments);
   }
 
   protected CatchClause(node: TSESTree.CatchClause): void {
@@ -540,7 +540,7 @@ class Referencer extends Visitor {
     } else {
       this.visit(node.name);
     }
-    this.visitType(node.typeParameters);
+    this.visitType(node.typeArguments);
     for (const attr of node.attributes) {
       this.visit(attr);
     }
@@ -562,8 +562,8 @@ class Referencer extends Visitor {
   }
 
   protected NewExpression(node: TSESTree.NewExpression): void {
-    this.visitChildren(node, ['typeParameters']);
-    this.visitType(node.typeParameters);
+    this.visitChildren(node, ['typeArguments']);
+    this.visitType(node.typeArguments);
   }
 
   protected PrivateIdentifier(): void {
@@ -613,7 +613,7 @@ class Referencer extends Visitor {
   ): void {
     this.visit(node.tag);
     this.visit(node.quasi);
-    this.visitType(node.typeParameters);
+    this.visitType(node.typeArguments);
   }
 
   protected TSAsExpression(node: TSESTree.TSAsExpression): void {

diff --git a/packages/scope-manager/src/referencer/TypeVisitor.ts b/packages/scope-manager/src/referencer/TypeVisitor.ts
@@ -120,7 +120,7 @@ class TypeVisitor extends Visitor {
 
   protected TSImportType(node: TSESTree.TSImportType): void {
     // the TS parser allows any type to be the parameter, but it's a syntax error - so we can ignore it
-    this.visit(node.typeParameters);
+    this.visit(node.typeArguments);
     // the qualifier is just part of a standard EntityName, so it should not be visited
   }
 
@@ -280,7 +280,7 @@ class TypeVisitor extends Visitor {
       this.#referencer.currentScope().referenceValue(entityName);
     }
 
-    this.visit(node.typeParameters);
+    this.visit(node.typeArguments);
   }
 
   protected TSTypeAnnotation(node: TSESTree.TSTypeAnnotation): void {

diff --git a/packages/type-utils/src/isUnsafeAssignment.ts b/packages/type-utils/src/isUnsafeAssignment.ts
@@ -57,7 +57,7 @@ export function isUnsafeAssignment(
       senderNode.callee.type === AST_NODE_TYPES.Identifier &&
       senderNode.callee.name === 'Map' &&
       senderNode.arguments.length === 0 &&
-      senderNode.typeParameters == null
+      senderNode.typeArguments == null
     ) {
       // special case to handle `new Map()`
       // unfortunately Map's default empty constructor is typed to return `Map<any, any>` :(