feat(eslint-plugin): [no-useless-default-assignment] add rule

eslint.config.mjs

@@ -162,6 +162,7 @@ export default defineConfig(
           varsIgnorePattern: '^_',
         },
       ],
+      '@typescript-eslint/no-useless-default-assignment': 'error',
       '@typescript-eslint/no-var-requires': 'off',
       '@typescript-eslint/prefer-literal-enum-member': [
         'error',

packages/eslint-plugin/docs/rules/no-useless-default-assignment.mdx

@@ -0,0 +1,54 @@
+---
+description: 'Disallow default values that will never be used.'
+---
+
+import Tabs from '@theme/Tabs';
+import TabItem from '@theme/TabItem';
+
+> 🛑 This file is source code, not the primary documentation location! 🛑
+>
+> See **https://typescript-eslint.io/rules/no-useless-default-assignment** for documentation.
+
+[Default parameters](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Functions/Default_parameters) and [default values](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Destructuring_assignment#default_value) are only used if the parameter or property is `undefined`.
+That can happen when a value is missing, or when one is provided and set to `undefined`.
+If a non-`undefined` value is guaranteed to be provided, then there is no need to define a default.
+
+## Examples
+
+<Tabs>
+<TabItem value="❌ Incorrect">
+
+```ts
+function Bar({ foo = '' }: { foo: string }) {
+  return foo;
+}
+
+const { foo = '' } = { foo: 'bar' };
+
+const [foo = ''] = ['bar'];
+
+[1, 2, 3].map((a = 42) => a + 1);
+```
+
+</TabItem>
+<TabItem value="✅ Correct">
+
+```ts
+function Bar({ foo = '' }: { foo?: string }) {
+  return foo;
+}
+
+const { foo = '' } = { foo: undefined };
+
+const [foo = ''] = [undefined];
+
+[1, 2, 3, undefined].map((a = 42) => a + 1);
+```
+
+</TabItem>
+</Tabs>
+
+## When Not To Use It
+
+If your codebase is still onboarding to TypeScript and/or has many existing `any`s or areas of loosely typed code, it may be difficult to enable this rule.
+You might consider using ESLint disable comments for those specific situations instead of completely disabling this rule.

packages/eslint-plugin/src/configs/eslintrc/all.ts

@@ -118,6 +118,7 @@ export = {
     '@typescript-eslint/no-use-before-define': 'error',
     'no-useless-constructor': 'off',
     '@typescript-eslint/no-useless-constructor': 'error',
+    '@typescript-eslint/no-useless-default-assignment': 'error',
     '@typescript-eslint/no-useless-empty-export': 'error',
     '@typescript-eslint/no-wrapper-object-types': 'error',
     '@typescript-eslint/non-nullable-type-assertion-style': 'error',

packages/eslint-plugin/src/configs/eslintrc/disable-type-checked.ts

@@ -44,6 +44,7 @@ export = {
     '@typescript-eslint/no-unsafe-return': 'off',
     '@typescript-eslint/no-unsafe-type-assertion': 'off',
     '@typescript-eslint/no-unsafe-unary-minus': 'off',
+    '@typescript-eslint/no-useless-default-assignment': 'off',
     '@typescript-eslint/non-nullable-type-assertion-style': 'off',
     '@typescript-eslint/only-throw-error': 'off',
     '@typescript-eslint/prefer-destructuring': 'off',

packages/eslint-plugin/src/configs/eslintrc/strict-type-checked-only.ts

@@ -39,6 +39,7 @@ export = {
     '@typescript-eslint/no-unsafe-member-access': 'error',
     '@typescript-eslint/no-unsafe-return': 'error',
     '@typescript-eslint/no-unsafe-unary-minus': 'error',
+    '@typescript-eslint/no-useless-default-assignment': 'error',
     'no-throw-literal': 'off',
     '@typescript-eslint/only-throw-error': 'error',
     'prefer-promise-reject-errors': 'off',

packages/eslint-plugin/src/configs/eslintrc/strict-type-checked.ts

@@ -68,6 +68,7 @@ export = {
     '@typescript-eslint/no-unused-vars': 'error',
     'no-useless-constructor': 'off',
     '@typescript-eslint/no-useless-constructor': 'error',
+    '@typescript-eslint/no-useless-default-assignment': 'error',
     '@typescript-eslint/no-wrapper-object-types': 'error',
     'no-throw-literal': 'off',
     '@typescript-eslint/only-throw-error': 'error',

packages/eslint-plugin/src/configs/flat/all.ts

@@ -132,6 +132,7 @@ export default (
       '@typescript-eslint/no-use-before-define': 'error',
       'no-useless-constructor': 'off',
       '@typescript-eslint/no-useless-constructor': 'error',
+      '@typescript-eslint/no-useless-default-assignment': 'error',
       '@typescript-eslint/no-useless-empty-export': 'error',
       '@typescript-eslint/no-wrapper-object-types': 'error',
       '@typescript-eslint/non-nullable-type-assertion-style': 'error',

packages/eslint-plugin/src/configs/flat/disable-type-checked.ts

@@ -51,6 +51,7 @@ export default (
     '@typescript-eslint/no-unsafe-return': 'off',
     '@typescript-eslint/no-unsafe-type-assertion': 'off',
     '@typescript-eslint/no-unsafe-unary-minus': 'off',
+    '@typescript-eslint/no-useless-default-assignment': 'off',
     '@typescript-eslint/non-nullable-type-assertion-style': 'off',
     '@typescript-eslint/only-throw-error': 'off',
     '@typescript-eslint/prefer-destructuring': 'off',

packages/eslint-plugin/src/configs/flat/strict-type-checked-only.ts

@@ -52,6 +52,7 @@ export default (
       '@typescript-eslint/no-unsafe-member-access': 'error',
       '@typescript-eslint/no-unsafe-return': 'error',
       '@typescript-eslint/no-unsafe-unary-minus': 'error',
+      '@typescript-eslint/no-useless-default-assignment': 'error',
       'no-throw-literal': 'off',
       '@typescript-eslint/only-throw-error': 'error',
       'prefer-promise-reject-errors': 'off',

packages/eslint-plugin/src/configs/flat/strict-type-checked.ts

@@ -81,6 +81,7 @@ export default (
       '@typescript-eslint/no-unused-vars': 'error',
       'no-useless-constructor': 'off',
       '@typescript-eslint/no-useless-constructor': 'error',
+      '@typescript-eslint/no-useless-default-assignment': 'error',
       '@typescript-eslint/no-wrapper-object-types': 'error',
       'no-throw-literal': 'off',
       '@typescript-eslint/only-throw-error': 'error',

packages/eslint-plugin/src/rules/index.ts

@@ -91,6 +91,7 @@ import noUnusedExpressions from './no-unused-expressions';
 import noUnusedVars from './no-unused-vars';
 import noUseBeforeDefine from './no-use-before-define';
 import noUselessConstructor from './no-useless-constructor';
+import noUselessDefaultAssignment from './no-useless-default-assignment';
 import noUselessEmptyExport from './no-useless-empty-export';
 import noVarRequires from './no-var-requires';
 import noWrapperObjectTypes from './no-wrapper-object-types';
@@ -225,6 +226,7 @@ const rules = {
   'no-unused-vars': noUnusedVars,
   'no-use-before-define': noUseBeforeDefine,
   'no-useless-constructor': noUselessConstructor,
+  'no-useless-default-assignment': noUselessDefaultAssignment,
   'no-useless-empty-export': noUselessEmptyExport,
   'no-var-requires': noVarRequires,
   'no-wrapper-object-types': noWrapperObjectTypes,

packages/eslint-plugin/src/rules/no-useless-default-assignment.ts

@@ -0,0 +1,252 @@
+import type { 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 {
+  createRule,
+  getParserServices,
+  isTypeAnyType,
+  isTypeFlagSet,
+  isTypeUnknownType,
+} from '../util';
+
+type MessageId = 'uselessDefaultAssignment';
+
+export default createRule<[], MessageId>({
+  name: 'no-useless-default-assignment',
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description: 'Disallow default values that will never be used',
+      recommended: 'strict',
+      requiresTypeChecking: true,
+    },
+    fixable: 'code',
+    messages: {
+      uselessDefaultAssignment:
+        'Default value is useless because the {{ type }} is not optional.',
+    },
+    schema: [
+      {
+        type: 'object',
+        additionalProperties: false,
+        properties: {},
+      },
+    ],
+  },
+  defaultOptions: [],
+  create(context) {
+    const services = getParserServices(context);
+    const checker = services.program.getTypeChecker();
+
+    function canBeUndefined(type: ts.Type): boolean {
+      // any and unknown can be undefined
+      if (isTypeAnyType(type) || isTypeUnknownType(type)) {
+        return true;
+      }
+      // Check if any part of the union includes undefined
+      return tsutils
+        .unionConstituents(type)
+        .some(part => isTypeFlagSet(part, ts.TypeFlags.Undefined));
+    }
+
+    function getPropertyType(
+      objectType: ts.Type,
+      propertyName: string,
+    ): ts.Type | null {
+      const symbol = objectType.getProperty(propertyName);
+      if (!symbol) {
+        return null;
+      }
+      return checker.getTypeOfSymbol(symbol);
+    }
+
+    function getArrayElementType(
+      arrayType: ts.Type,
+      elementIndex: number,
+    ): ts.Type | null {
+      if (checker.isTupleType(arrayType)) {
+        const tupleArgs = checker.getTypeArguments(arrayType);
+        if (elementIndex < tupleArgs.length) {
+          return tupleArgs[elementIndex];
+        }
+      }
+
+      return null;
+    }
+
+    function isCallbackFunction(
+      functionNode:
+        | TSESTree.ArrowFunctionExpression
+        | TSESTree.FunctionExpression,
+    ): boolean {
+      const parentType = functionNode.parent.type;
+      return (
+        parentType !== AST_NODE_TYPES.MethodDefinition &&
+        parentType !== AST_NODE_TYPES.VariableDeclarator &&
+        parentType !== AST_NODE_TYPES.Property &&
+        parentType !== AST_NODE_TYPES.ExpressionStatement &&
+        parentType !== AST_NODE_TYPES.ReturnStatement
+      );
+    }
+
+    function checkAssignmentPattern(node: TSESTree.AssignmentPattern): void {
+      const parent = node.parent;
+
+      // Handle callback parameters (like array.map((a = 42) => ...))
+      if (
+        parent.type === AST_NODE_TYPES.ArrowFunctionExpression ||
+        parent.type === AST_NODE_TYPES.FunctionExpression
+      ) {
+        const paramIndex = parent.params.indexOf(node);
+        if (paramIndex !== -1) {
+          // Only check if this is actually a callback, not a regular function
+          if (!isCallbackFunction(parent)) {
+            return;
+          }
+
+          const tsFunc = services.esTreeNodeToTSNodeMap.get(parent);
+          if (ts.isFunctionLike(tsFunc)) {
+            const signature = checker.getSignatureFromDeclaration(tsFunc);
+            if (signature) {
+              const params = signature.getParameters();
+              if (paramIndex < params.length) {
+                const paramType = checker.getTypeOfSymbol(params[paramIndex]);
+                if (!canBeUndefined(paramType)) {
+                  reportUselessDefault(node, 'parameter');
+                }
+              }
+            }
+          }
+        }
+        return;
+      }
+
+      // Handle destructuring patterns
+      if (parent.type === AST_NODE_TYPES.Property) {
+        // This is a property in an object destructuring pattern
+        const objectPattern = parent.parent as TSESTree.ObjectPattern;
+
+        const sourceType = getSourceTypeForPattern(objectPattern);
+        if (!sourceType) {
+          return;
+        }
+
+        const propertyName = getPropertyName(parent.key);
+        if (!propertyName) {
+          return;
+        }
+
+        const propertyType = getPropertyType(sourceType, propertyName);
+        if (!propertyType) {
+          return;
+        }
+
+        if (!canBeUndefined(propertyType)) {
+          reportUselessDefault(node, 'property');
+        }
+      } else if (parent.type === AST_NODE_TYPES.ArrayPattern) {
+        // This is an element in an array destructuring pattern
+        const sourceType = getSourceTypeForPattern(parent);
+        if (!sourceType) {
+          return;
+        }
+
+        const elementIndex = parent.elements.indexOf(node);
+        if (elementIndex === -1) {
+          return;
+        }
+
+        const elementType = getArrayElementType(sourceType, elementIndex);
+        if (!elementType) {
+          return;
+        }
+
+        if (!canBeUndefined(elementType)) {
+          reportUselessDefault(node, 'property');
+        }
+      }
+    }
+
+    function getSourceTypeForPattern(
+      pattern: TSESTree.ArrayPattern | TSESTree.ObjectPattern,
+    ): ts.Type | null {
+      let currentNode: TSESTree.Node = pattern;
+
+      // Walk up through nested patterns
+      while (
+        currentNode.parent.type === AST_NODE_TYPES.AssignmentPattern ||
+        currentNode.parent.type === AST_NODE_TYPES.Property ||
+        currentNode.parent.type === AST_NODE_TYPES.ObjectPattern ||
+        currentNode.parent.type === AST_NODE_TYPES.ArrayPattern
+      ) {
+        currentNode = currentNode.parent;
+      }
+
+      const parent = currentNode.parent;
+
+      // Handle variable declarator
+      if (parent.type === AST_NODE_TYPES.VariableDeclarator && parent.init) {
+        const tsNode = services.esTreeNodeToTSNodeMap.get(parent.init);
+        return checker.getTypeAtLocation(tsNode);
+      }
+
+      // Handle function parameter
+      if (
+        parent.type === AST_NODE_TYPES.FunctionExpression ||
+        parent.type === AST_NODE_TYPES.ArrowFunctionExpression ||
+        parent.type === AST_NODE_TYPES.FunctionDeclaration
+      ) {
+        const paramIndex = parent.params.indexOf(
+          currentNode as TSESTree.Parameter,
+        );
+        const tsFunc = services.esTreeNodeToTSNodeMap.get(parent);
+        const signature = checker.getSignatureFromDeclaration(tsFunc);
+        if (!signature) {
+          return null;
+        }
+        const params = signature.getParameters();
+        return checker.getTypeOfSymbol(params[paramIndex]);
+      }
+
+      return null;
+    }
+
+    function getPropertyName(
+      key: TSESTree.Expression | TSESTree.PrivateIdentifier,
+    ): string | null {
+      switch (key.type) {
+        case AST_NODE_TYPES.Identifier:
+          return key.name;
+        case AST_NODE_TYPES.Literal:
+          return String(key.value);
+        default:
+          return null;
+      }
+    }
+
+    function reportUselessDefault(
+      node: TSESTree.AssignmentPattern,
+      type: 'parameter' | 'property',
+    ): void {
+      context.report({
+        node: node.right,
+        messageId: 'uselessDefaultAssignment',
+        data: { type },
+        fix(fixer) {
+          // Remove from before the = to the end of the default value
+          // Find the start position (including whitespace before =)
+          const start = node.left.range[1];
+          const end = node.range[1];
+          return fixer.removeRange([start, end]);
+        },
+      });
+    }
+
+    return {
+      AssignmentPattern: checkAssignmentPattern,
+    };
+  },
+});