typescript-eslint · JoshuaKGoldberg · Oct 21, 2024 · Oct 14, 2024 · Oct 15, 2024 · Oct 15, 2024
diff --git a/packages/eslint-plugin/src/rules/no-unnecessary-type-parameters.ts b/packages/eslint-plugin/src/rules/no-unnecessary-type-parameters.ts
@@ -1,13 +1,18 @@
 import type { Reference } from '@typescript-eslint/scope-manager';
-import type { TSESTree } from '@typescript-eslint/utils';
+import type { TSESLint, TSESTree } from '@typescript-eslint/utils';
 
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
 import * as tsutils from 'ts-api-utils';
 import * as ts from 'typescript';
 
 import type { MakeRequired } from '../util';
 
-import { createRule, getParserServices, nullThrows } from '../util';
+import {
+  createRule,
+  getParserServices,
+  nullThrows,
+  NullThrowsReasons,
+} from '../util';
 
 type NodeWithTypeParameters = MakeRequired<
   ts.ClassLikeDeclaration | ts.SignatureDeclaration,
@@ -23,7 +28,10 @@ export default createRule({
       recommended: 'strict',
       requiresTypeChecking: true,
     },
+    hasSuggestions: true,
     messages: {
+      replaceUsagesWithConstraint:
+        'Replace all usages of type parameter with its constraint.',
       sole: 'Type parameter {{name}} is {{uses}} in the {{descriptor}} signature.',
     },
     schema: [],
@@ -84,6 +92,88 @@ export default createRule({
             descriptor,
             uses: identifierCounts === 1 ? 'never used' : 'used only once',
           },
+          suggest: [
+            {
+              messageId: 'replaceUsagesWithConstraint',
+              *fix(fixer): Generator<TSESLint.RuleFix> {
+                // Replace all the usages of the type parameter with the constraint...
+
+                const constraint = esTypeParameter.constraint;
+                // special case - a constraint of 'any' actually acts like 'unknown'
+                const constraintText =
+                  constraint != null &&
+                  constraint.type !== AST_NODE_TYPES.TSAnyKeyword
+                    ? context.sourceCode.getText(constraint)
+                    : 'unknown';
+                for (const reference of smTypeParameterVariable.references) {
+                  if (reference.isTypeReference) {
+                    const referenceNode = reference.identifier;
+                    yield fixer.replaceText(referenceNode, constraintText);
+                  }
+                }
+
+                // ...and remove the type parameter itself from the declaration.
+
+                const typeParamsNode = nullThrows(
+                  node.typeParameters,
+                  'node should have type parameters',
+                );
+
+                // We are assuming at this point that the reported type parameter
+                // is present in the inspected node's type parameters.
+                if (typeParamsNode.params.length === 1) {
+                  // Remove the whole <T> generic syntax if we're removing the only type parameter in the list.
+                  yield fixer.remove(typeParamsNode);
+                } else {
+                  const index = typeParamsNode.params.indexOf(esTypeParameter);
+
+                  if (index === 0) {
+                    const commaAfter = nullThrows(
+                      context.sourceCode.getTokenAfter(
+                        esTypeParameter,
+                        token => token.value === ',',
+                      ),
+                      NullThrowsReasons.MissingToken(
+                        'comma',
+                        'type parameter list',
+                      ),
+                    );
+
+                    const tokenAfterComma = nullThrows(
+                      context.sourceCode.getTokenAfter(commaAfter, {
+                        includeComments: true,
+                      }),
+                      NullThrowsReasons.MissingToken(
+                        'token',
+                        'type parameter list',
+                      ),
+                    );
+
+                    yield fixer.removeRange([
+                      esTypeParameter.range[0],
+                      tokenAfterComma.range[0],
+                    ]);
+                  } else {
+                    const commaBefore = nullThrows(
+                      context.sourceCode.getTokenBefore(
+                        esTypeParameter,
+                        token => token.value === ',',
+                      ),
+                      NullThrowsReasons.MissingToken(
+                        'comma',
+                        'type parameter list',
+                      ),
+                    );
+
+                    yield fixer.removeRange([
+                      commaBefore.range[0],
+                      esTypeParameter.range[1],
+                    ]);
+                  }
+                }
+              },
+            },
+          ],
         });
       }
     }