typescript-eslint · JoshuaKGoldberg · Sep 2, 2024 · Jul 25, 2024 · Jul 25, 2024 · Jul 25, 2024
diff --git a/packages/eslint-plugin/src/rules/member-ordering.ts b/packages/eslint-plugin/src/rules/member-ordering.ts
@@ -299,75 +299,73 @@ export const defaultOrder: MemberType[] = [
   'method',
 ];
 
-const allMemberTypes = Array.from(
-  (
-    [
-      'readonly-signature',
-      'signature',
-      'readonly-field',
-      'field',
-      'method',
-      'call-signature',
-      'constructor',
-      'accessor',
-      'get',
-      'set',
-      'static-initialization',
-    ] as const
-  ).reduce<Set<MemberType>>((all, type) => {
-    all.add(type);
-
-    (['public', 'protected', 'private', '#private'] as const).forEach(
-      accessibility => {
-        if (
+const allMemberTypes = [
+  ...new Set(
+    (
+      [
+        'readonly-signature',
+        'signature',
+        'readonly-field',
+        'field',
+        'method',
+        'call-signature',
+        'constructor',
+        'accessor',
+        'get',
+        'set',
+        'static-initialization',
+      ] as const
+    ).flatMap(type => [
+      type,
+
+      ...(['public', 'protected', 'private', '#private'] as const)
+        .flatMap<MemberType>(accessibility => [
           type !== 'readonly-signature' &&
           type !== 'signature' &&
           type !== 'static-initialization' &&
           type !== 'call-signature' &&
           !(type === 'constructor' && accessibility === '#private')
-        ) {
-          all.add(`${accessibility}-${type}`); // e.g. `public-field`
-        }
+            ? `${accessibility}-${type}` // e.g. `public-field`
+            : [],
 
-        // Only class instance fields, methods, accessors, get and set can have decorators attached to them
-        if (
+          // Only class instance fields, methods, accessors, get and set can have decorators attached to them
           accessibility !== '#private' &&
           (type === 'readonly-field' ||
             type === 'field' ||
             type === 'method' ||
             type === 'accessor' ||
             type === 'get' ||
             type === 'set')
-        ) {
-          all.add(`${accessibility}-decorated-${type}`);
-          all.add(`decorated-${type}`);
-        }
+            ? [`${accessibility}-decorated-${type}`, `decorated-${type}`]
+            : [],
 
-        if (
           type !== 'constructor' &&
           type !== 'readonly-signature' &&
           type !== 'signature' &&
           type !== 'call-signature'
-        ) {
-          // There is no `static-constructor` or `instance-constructor` or `abstract-constructor`
-          if (accessibility === '#private' || accessibility === 'private') {
            (['static', 'instance'] as const).forEach(scope => {
-              all.add(`${scope}-${type}`);
-              all.add(`${accessibility}-${scope}-${type}`);
-            });
-          } else {
-            (['static', 'instance', 'abstract'] as const).forEach(scope => {
-              all.add(`${scope}-${type}`);
-              all.add(`${accessibility}-${scope}-${type}`);
-            });
-          }
-        }
-      },
-    );
-
-    return all;
-  }, new Set<MemberType>()),
-);
+            ? (
+                [
+                  'static',
+                  'instance',
+                  // There is no `static-constructor` or `instance-constructor` or `abstract-constructor`
+                  ...(accessibility === '#private' ||
+                  accessibility === 'private'
+                    ? []
+                    : (['abstract'] as const)),
+                ] as const
+              ).flatMap(
+                scope =>
+                  [
+                    `${scope}-${type}`,
+                    `${accessibility}-${scope}-${type}`,
+                  ] as const,
+              )
+            : [],
+        ])
+        .flat(),
+    ]),
+  ),
+];
 
 const functionExpressions = [
   AST_NODE_TYPES.FunctionExpression,

diff --git a/packages/eslint-plugin/src/rules/naming-convention-utils/parse-options.ts b/packages/eslint-plugin/src/rules/naming-convention-utils/parse-options.ts
@@ -82,13 +82,12 @@ function normalizeOption(option: Selector): NormalizedSelector[] {
 function parseOptions(context: Context): ParsedOptions {
   const normalizedOptions = context.options.flatMap(normalizeOption);
 
-  const result = getEnumNames(Selectors).reduce((acc, k) => {
-    acc[k] = createValidator(k, context, normalizedOptions);
-    return acc;
-    // eslint-disable-next-line @typescript-eslint/prefer-reduce-type-parameter
-  }, {} as ParsedOptions);
-
-  return result;
+  return Object.fromEntries(
+    getEnumNames(Selectors).map(k => [
+      k,
+      createValidator(k, context, normalizedOptions),
+    ]),
+  ) as ParsedOptions;
 }
 
 export { parseOptions };
diff --git a/packages/eslint-plugin/src/rules/no-type-alias.ts b/packages/eslint-plugin/src/rules/no-type-alias.ts
@@ -324,10 +324,7 @@ export default createRule<Options, MessageIds>({
         node.type === AST_NODE_TYPES.TSUnionType ||
         node.type === AST_NODE_TYPES.TSIntersectionType
       ) {
-        return node.types.reduce<TypeWithLabel[]>((acc, type) => {
-          acc.push(...getTypes(type, node.type));
-          return acc;
-        }, []);
+        return node.types.flatMap(type => getTypes(type, node.type));
       }
       return [{ node, compositionType }];
     }

diff --git a/packages/eslint-plugin/tests/configs.test.ts b/packages/eslint-plugin/tests/configs.test.ts
@@ -16,13 +16,6 @@ const EXTENSION_RULES = Object.entries(rules)
       ] as const,
   );
 
-function entriesToObject<T = unknown>(value: [string, T][]): Record<string, T> {
-  return value.reduce<Record<string, T>>((accum, [k, v]) => {
-    accum[k] = v;
-    return accum;
-  }, {});
-}
-
 function filterRules(
   values: Record<string, string | unknown[]>,
 ): [string, string | unknown[]][] {
@@ -118,7 +111,9 @@ describe('all.ts', () => {
       excludeDeprecated: true,
     });
 
-    expect(entriesToObject(ruleConfigs)).toEqual(entriesToObject(configRules));
+    expect(Object.fromEntries(ruleConfigs)).toEqual(
+      Object.fromEntries(configRules),
+    );
   });
 
   itHasBaseRulesOverriden(unfilteredConfigRules);
@@ -135,7 +130,9 @@ describe('disable-type-checked.ts', () => {
       .filter(([, rule]) => rule.meta.docs?.requiresTypeChecking)
       .map(([name]) => [`${RULE_NAME_PREFIX}${name}`, 'off']);
 
-    expect(entriesToObject(ruleConfigs)).toEqual(entriesToObject(configRules));
+    expect(Object.fromEntries(ruleConfigs)).toEqual(
+      Object.fromEntries(configRules),
+    );
   });
 });
 
@@ -151,7 +148,9 @@ describe('recommended.ts', () => {
       recommendations: ['recommended'],
     });
 
-    expect(entriesToObject(ruleConfigs)).toEqual(entriesToObject(configRules));
+    expect(Object.fromEntries(ruleConfigs)).toEqual(
+      Object.fromEntries(configRules),
+    );
   });
 
   itHasBaseRulesOverriden(unfilteredConfigRules);
@@ -168,7 +167,9 @@ describe('recommended-type-checked.ts', () => {
       recommendations: ['recommended'],
     });
 
-    expect(entriesToObject(ruleConfigs)).toEqual(entriesToObject(configRules));
+    expect(Object.fromEntries(ruleConfigs)).toEqual(
+      Object.fromEntries(configRules),
+    );
   });
 
   itHasBaseRulesOverriden(unfilteredConfigRules);
@@ -186,7 +187,9 @@ describe('recommended-type-checked-only.ts', () => {
       recommendations: ['recommended'],
     }).filter(([ruleName]) => ruleName);
 
-    expect(entriesToObject(ruleConfigs)).toEqual(entriesToObject(configRules));
+    expect(Object.fromEntries(ruleConfigs)).toEqual(
+      Object.fromEntries(configRules),
+    );
   });
 
   itHasBaseRulesOverriden(unfilteredConfigRules);
@@ -205,7 +208,9 @@ describe('strict.ts', () => {
       recommendations: ['recommended', 'strict'],
     });
 
-    expect(entriesToObject(ruleConfigs)).toEqual(entriesToObject(configRules));
+    expect(Object.fromEntries(ruleConfigs)).toEqual(
+      Object.fromEntries(configRules),
+    );
   });
 
   itHasBaseRulesOverriden(unfilteredConfigRules);
@@ -222,7 +227,9 @@ describe('strict-type-checked.ts', () => {
       excludeDeprecated: true,
       recommendations: ['recommended', 'strict'],
     });
-    expect(entriesToObject(ruleConfigs)).toEqual(entriesToObject(configRules));
+    expect(Object.fromEntries(ruleConfigs)).toEqual(
+      Object.fromEntries(configRules),
+    );
   });
 
   itHasBaseRulesOverriden(unfilteredConfigRules);
@@ -241,7 +248,9 @@ describe('strict-type-checked-only.ts', () => {
       recommendations: ['recommended', 'strict'],
     }).filter(([ruleName]) => ruleName);
 
-    expect(entriesToObject(ruleConfigs)).toEqual(entriesToObject(configRules));
+    expect(Object.fromEntries(ruleConfigs)).toEqual(
+      Object.fromEntries(configRules),
+    );
   });
 
   itHasBaseRulesOverriden(unfilteredConfigRules);
@@ -259,7 +268,9 @@ describe('stylistic.ts', () => {
       recommendations: ['stylistic'],
     });
 
-    expect(entriesToObject(ruleConfigs)).toEqual(entriesToObject(configRules));
+    expect(Object.fromEntries(ruleConfigs)).toEqual(
+      Object.fromEntries(configRules),
+    );
   });
 
   itHasBaseRulesOverriden(unfilteredConfigRules);
@@ -275,7 +286,9 @@ describe('stylistic-type-checked.ts', () => {
   });
 
   it('contains all stylistic rules, excluding deprecated ones', () => {
-    expect(entriesToObject(ruleConfigs)).toEqual(entriesToObject(configRules));
+    expect(Object.fromEntries(ruleConfigs)).toEqual(
+      Object.fromEntries(configRules),
+    );
   });
 
   itHasBaseRulesOverriden(unfilteredConfigRules);
@@ -293,7 +306,9 @@ describe('stylistic-type-checked-only.ts', () => {
       recommendations: ['stylistic'],
     }).filter(([ruleName]) => ruleName);
 
-    expect(entriesToObject(ruleConfigs)).toEqual(entriesToObject(configRules));
+    expect(Object.fromEntries(ruleConfigs)).toEqual(
+      Object.fromEntries(configRules),
+    );
   });
 
   itHasBaseRulesOverriden(unfilteredConfigRules);

diff --git a/packages/eslint-plugin/tests/rules/no-base-to-string.test.ts b/packages/eslint-plugin/tests/rules/no-base-to-string.test.ts
@@ -44,9 +44,9 @@ ruleTester.run('no-base-to-string', rule, {
     ...literalList.map(i => `\`\${${i}}\`;`),
 
     // operator + +=
-    ...literalListWrapped
-      .map(l => literalListWrapped.map(r => `${l} + ${r};`))
-      .reduce((pre, cur) => [...pre, ...cur]),
+    ...literalListWrapped.flatMap(l =>
+      literalListWrapped.map(r => `${l} + ${r};`),
+    ),
 
     // toString()
     ...literalListWrapped.map(i => `${i === '1' ? `(${i})` : i}.toString();`),

diff --git a/packages/eslint-plugin/tests/rules/no-explicit-any.test.ts b/packages/eslint-plugin/tests/rules/no-explicit-any.test.ts
@@ -1198,7 +1198,7 @@ const test = <T extends Partial<never>>() => {};
         ],
       },
     ] as RuleInvalidTestCase[]
-  ).reduce<RuleInvalidTestCase[]>((acc, testCase) => {
+  ).flatMap(testCase => {
     const suggestions = (code: string): RuleSuggestionOutput[] => [
       {
         messageId: 'suggestUnknown',
@@ -1209,38 +1209,37 @@ const test = <T extends Partial<never>>() => {};
         output: code.replace(/any/, 'never'),
       },
     ];
-    acc.push({
-      ...testCase,
-      errors: testCase.errors.map(e => ({
-        ...e,
-        suggestions: e.suggestions ?? suggestions(testCase.code),
-      })),
-    });
-    const options = testCase.options ?? [];
     const code = `// fixToUnknown: true\n${testCase.code}`;
-    acc.push({
-      code,
-      output: code.replaceAll('any', 'unknown'),
-      options: [{ ...options[0], fixToUnknown: true }],
-      errors: testCase.errors.map(err => {
-        if (err.line === undefined) {
-          return err;
-        }
-
-        return {
-          ...err,
-          line: err.line + 1,
-          suggestions:
-            err.suggestions?.map(
-              (s): RuleSuggestionOutput => ({
-                ...s,
-                output: `// fixToUnknown: true\n${s.output}`,
-              }),
-            ) ?? suggestions(code),
-        };
-      }),
-    });
+    return [
+      {
+        ...testCase,
+        errors: testCase.errors.map(e => ({
+          ...e,
+          suggestions: e.suggestions ?? suggestions(testCase.code),
+        })),
+      },
+      {
+        code,
+        output: code.replaceAll('any', 'unknown'),
+        options: [{ ...testCase.options?.[0], fixToUnknown: true }],
+        errors: testCase.errors.map(err => {
+          if (err.line === undefined) {
+            return err;
+          }
 
-    return acc;
-  }, []),
+          return {
+            ...err,
+            line: err.line + 1,
+            suggestions:
+              err.suggestions?.map(
+                (s): RuleSuggestionOutput => ({
+                  ...s,
+                  output: `// fixToUnknown: true\n${s.output}`,
+                }),
+              ) ?? suggestions(code),
+          };
+        }),
+      },
+    ];
+  }),
 });