eslint-plugin-ts-data-forge 0.8.1 → 0.8.3

package/src/rules/prefer-arr-scan.test.mts

@@ -293,3 +293,152 @@ describe('prefer-arr-scan', () => {
     ],
   });
 });
+
+describe('prefer-arr-scan through type wrappers', () => {
+  tester.run('prefer-arr-scan', preferArrScan, {
+    valid: [],
+    invalid: [
+      {
+        name: 'a seed whose `!` hides that it may be undefined keeps the `??`',
+        code: dedent`
+          import { Arr } from 'ts-data-forge';
+          declare const xs: readonly number[];
+          declare const init: number | undefined;
+          const totals = xs.reduce(
+            (acc, x) => [...acc, (acc.at(-1) ?? 0) + x],
+            [init!],
+          );
+        `,
+        output: dedent`
+          import { Arr } from 'ts-data-forge';
+          declare const xs: readonly number[];
+          declare const init: number | undefined;
+          const totals = Arr.scan(xs, (acc, x) => (acc ?? 0) + x, init!);
+        `,
+        errors: [{ messageId: 'preferArrScanAccumulate' }],
+      },
+      {
+        name: 'an element cast away from undefined keeps the `??`',
+        code: dedent`
+          import { Arr } from 'ts-data-forge';
+          declare const xs: readonly (number | undefined)[];
+          const totals = xs.reduce<readonly number[]>(
+            (acc, x) => [...acc, ((acc.at(-1) ?? 0) && x) as number],
+            [0],
+          );
+        `,
+        output: dedent`
+          import { Arr } from 'ts-data-forge';
+          declare const xs: readonly (number | undefined)[];
+          const totals = Arr.scan(xs, (acc, x) => ((acc ?? 0) && x) as number, 0);
+        `,
+        errors: [{ messageId: 'preferArrScanAccumulate' }],
+      },
+      {
+        name: 'a spread accumulator wrapped in `as`',
+        code: dedent`
+          import { Arr } from 'ts-data-forge';
+          declare const xs: readonly number[];
+          const totals = xs.reduce<readonly number[]>(
+            (acc, x) => [...(acc as readonly number[]), (acc.at(-1) ?? 0) + x],
+            [0],
+          );
+        `,
+        output: dedent`
+          import { Arr } from 'ts-data-forge';
+          declare const xs: readonly number[];
+          const totals = Arr.scan(xs, (acc, x) => (acc) + x, 0);
+        `,
+        errors: [{ messageId: 'preferArrScanAccumulate' }],
+      },
+      {
+        name: 'an Arr.toPushed target wrapped in `!`',
+        code: dedent`
+          import { Arr } from 'ts-data-forge';
+          declare const xs: readonly number[];
+          const totals = xs.reduce<readonly number[]>(
+            (acc, x) => Arr.toPushed(acc!, (acc.at(-1) ?? 0) + x),
+            [0],
+          );
+        `,
+        output: dedent`
+          import { Arr } from 'ts-data-forge';
+          declare const xs: readonly number[];
+          const totals = Arr.scan(xs, (acc, x) => (acc) + x, 0);
+        `,
+        errors: [{ messageId: 'preferArrScanAccumulate' }],
+      },
+      {
+        name: 'the sliced array wrapped in `as`',
+        code: dedent`
+          declare const xs: readonly string[];
+          const ys = xs.map((_, i) =>
+            (xs as readonly string[]).slice(0, i + 1).join(''),
+          );
+        `,
+        errors: [{ messageId: 'preferArrScanPrefix' }],
+      },
+    ],
+  });
+});
+
+describe('prefer-arr-scan with parenthesized operands', () => {
+  tester.run('prefer-arr-scan', preferArrScan, {
+    valid: [],
+    invalid: [
+      {
+        name: 'an object literal element stays an expression body',
+        code: dedent`
+          import { Arr } from 'ts-data-forge';
+          declare const xs: readonly number[];
+          const totals = xs.reduce(
+            (acc, x) => [...acc, { sum: acc.at(-1)!.sum + x }],
+            [{ sum: 0 }],
+          );
+        `,
+        output: dedent`
+          import { Arr } from 'ts-data-forge';
+          declare const xs: readonly number[];
+          const totals = Arr.scan(xs, (acc, x) => ({ sum: acc!.sum + x }), { sum: 0 });
+        `,
+        errors: [{ messageId: 'preferArrScanAccumulate' }],
+      },
+      {
+        name: 'an object literal element under a wrapper stays an expression body',
+        code: dedent`
+          import { Arr } from 'ts-data-forge';
+          declare const xs: readonly number[];
+          const totals = xs.reduce(
+            (acc, x) => [...acc, { sum: acc.at(-1)!.sum + x } as const],
+            [{ sum: 0 }],
+          );
+        `,
+        output: dedent`
+          import { Arr } from 'ts-data-forge';
+          declare const xs: readonly number[];
+          const totals = Arr.scan(xs, (acc, x) => ({ sum: acc!.sum + x } as const), { sum: 0 });
+        `,
+        errors: [{ messageId: 'preferArrScanAccumulate' }],
+      },
+      {
+        name: 'a sequence element and seed keep their parentheses',
+        code: dedent`
+          import { Arr } from 'ts-data-forge';
+          declare const xs: readonly number[];
+          declare const log: (n: number) => void;
+          const totals = xs.reduce<readonly number[]>(
+            (acc, x) => [...acc, (log(x), (acc.at(-1) ?? 0) + x)],
+            [(log(0), 0)],
+          );
+        `,
+        output: dedent`
+          import { Arr } from 'ts-data-forge';
+          declare const xs: readonly number[];
+          declare const log: (n: number) => void;
+          const totals = Arr.scan(xs, (acc, x) => (log(x), (acc) + x), (log(0), 0));
+        `,
+        errors: [{ messageId: 'preferArrScanAccumulate' }],
+      },
+    ],
+  });
+});

package/src/rules/prefer-arr-sum.mts

@@ -4,7 +4,12 @@ import {
   type TSESTree,
 } from '@typescript-eslint/utils';
 import { Arr, pipe } from 'ts-data-forge';
-import { type TypeReference } from 'typescript';
+import type { TypeReference } from 'typescript';
+import {
+  skipTypeWrappers,
+  toArgumentText,
+  typeWrapperLayers,
+} from './ast-utils.mjs';
 import {
   buildImportFixes,
   getNamedImports,
@@ -50,8 +55,10 @@ export const preferArrSum: TSESLint.RuleModule<MessageIds, Options> = {
     return {
       CallExpression: (node) => {
         // Check for xs.reduce(...)
+        // (`xs[reduce]` calls whatever method the variable `reduce` names)
         if (
           node.callee.type !== AST_NODE_TYPES.MemberExpression ||
+          node.callee.computed ||
           node.callee.property.type !== AST_NODE_TYPES.Identifier ||
           node.callee.property.name !== 'reduce'
         ) {
@@ -61,11 +68,16 @@ export const preferArrSum: TSESLint.RuleModule<MessageIds, Options> = {
         const arrayExpression = node.callee.object;
 
         // Check if we have 2 arguments: reducer function and initial value 0
-        if (!Arr.isFixedLengthTuple(2, node.arguments)) return;
+        if (!Arr.isFixedLengthTuple(2, node.arguments)) {
+          return;
+        }
 
         const reducer = node.arguments[0];
 
-        const initialValue = node.arguments[1];
+        // The initial value and the operands of the body are read through
+        // type wrappers: `0 as number` is still 0, `(b satisfies number)` is
+        // still `b`. Types are asked of the values underneath too.
+        const initialValue = skipTypeWrappers(node.arguments[1]);
 
         // Check initial value is 0
         if (
@@ -96,27 +108,47 @@ export const preferArrSum: TSESLint.RuleModule<MessageIds, Options> = {
 
         const checker = services?.program?.getTypeChecker();
 
-        if (checker === undefined) return;
+        if (checker === undefined) {
+          return;
+        }
 
-        // Case 1: (a, b) => a + b
         if (
-          body.type === AST_NODE_TYPES.BinaryExpression &&
-          body.operator === '+' &&
-          body.left.type === AST_NODE_TYPES.Identifier &&
-          body.left.name === param1.name &&
-          body.right.type === AST_NODE_TYPES.Identifier &&
-          body.right.name === param2.name
+          body.type !== AST_NODE_TYPES.BinaryExpression ||
+          body.operator !== '+'
         ) {
-          // Check if arrayExpression type is number[] or compatible
+          return;
+        }
 
-          const type = pipe(
-            services?.esTreeNodeToTSNodeMap?.get(arrayExpression),
-          ).mapNullable((tsNode) => checker.getTypeAtLocation(tsNode)).value;
+        const left = skipTypeWrappers(body.left);
+
+        const right = skipTypeWrappers(body.right);
+
+        // Case 1: (a, b) => a + b
+        if (
+          left.type === AST_NODE_TYPES.Identifier &&
+          left.name === param1.name &&
+          right.type === AST_NODE_TYPES.Identifier &&
+          right.name === param2.name
+        ) {
+          // Check if arrayExpression type is number[] or compatible at every
+          // layer of type wrappers: a cast does not turn strings, which `+`
+          // concatenates, into numbers.
+          const isNumberArray = (
+            // AST nodes hold mutable child arrays, so they are not deeply readonly.
+            // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+            expression: TSESTree.Node,
+          ): boolean => {
+            const type = pipe(
+              services?.esTreeNodeToTSNodeMap?.get(expression),
+            ).mapNullable((tsNode) => checker.getTypeAtLocation(tsNode)).value;
+
+            if (
+              type === undefined || // Check if it's an array type or tuple type
+              (!checker.isArrayType(type) && !checker.isTupleType(type))
+            ) {
+              return false;
+            }
 
-          if (
-            type !== undefined && // Check if it's an array type or tuple type
-            (checker.isArrayType(type) || checker.isTupleType(type))
-          ) {
             // Get type arguments using the official API
             // TypeReference has typeArguments that we can access
             const typeArguments = checker.getTypeArguments(
@@ -124,20 +156,22 @@ export const preferArrSum: TSESLint.RuleModule<MessageIds, Options> = {
               type as TypeReference,
             );
 
-            if (Arr.isNonEmpty(typeArguments)) {
-              const elementType = typeArguments[0];
-
-              const numberType = checker.getNumberType();
-
-              // Check if element type is assignable to number
-              if (checker.isTypeAssignableTo(elementType, numberType)) {
-                mut_nodesToFix.push({
-                  node,
-                  arrayExpression,
-                  messageId: 'useArrSum',
-                });
-              }
-            }
+            // Check if element type is assignable to number
+            return (
+              Arr.isNonEmpty(typeArguments) &&
+              checker.isTypeAssignableTo(
+                typeArguments[0],
+                checker.getNumberType(),
+              )
+            );
+          };
+
+          if (typeWrapperLayers(arrayExpression).every(isNumberArray)) {
+            mut_nodesToFix.push({
+              node,
+              arrayExpression,
+              messageId: 'useArrSum',
+            });
           }
 
           return;
@@ -145,14 +179,12 @@ export const preferArrSum: TSESLint.RuleModule<MessageIds, Options> = {
 
         // Case 2: (a, b) => a.prop + b.prop or a['prop'] + b['prop']
         if (
-          body.type === AST_NODE_TYPES.BinaryExpression &&
-          body.operator === '+' &&
-          body.left.type === AST_NODE_TYPES.MemberExpression &&
-          body.right.type === AST_NODE_TYPES.MemberExpression
+          left.type === AST_NODE_TYPES.MemberExpression &&
+          right.type === AST_NODE_TYPES.MemberExpression
         ) {
-          const leftObj = body.left.object;
+          const leftObj = skipTypeWrappers(left.object);
 
-          const rightObj = body.right.object;
+          const rightObj = skipTypeWrappers(right.object);
 
           if (
             leftObj.type !== AST_NODE_TYPES.Identifier ||
@@ -164,38 +196,40 @@ export const preferArrSum: TSESLint.RuleModule<MessageIds, Options> = {
           }
 
           // Check if both access the same property
-          const leftProp = body.left.property;
+          const leftProp = left.property;
 
-          const rightProp = body.right.property;
+          const rightProp = right.property;
 
           let mut_propName: string | undefined;
 
           if (
             leftProp.type === AST_NODE_TYPES.Identifier &&
-            !body.left.computed &&
+            !left.computed &&
             rightProp.type === AST_NODE_TYPES.Identifier &&
-            !body.right.computed &&
+            !right.computed &&
             leftProp.name === rightProp.name
           ) {
             mut_propName = leftProp.name;
           } else if (
             leftProp.type === AST_NODE_TYPES.Literal &&
-            body.left.computed &&
+            left.computed &&
             rightProp.type === AST_NODE_TYPES.Literal &&
-            body.right.computed &&
+            right.computed &&
             leftProp.value === rightProp.value &&
             typeof leftProp.value === 'string'
           ) {
             mut_propName = leftProp.value;
           }
 
-          if (mut_propName === undefined) return;
+          if (mut_propName === undefined) {
+            return;
+          }
 
           // Check if property type is number
           if (services?.program !== undefined && services.program !== null) {
-            const tsLeftProp = services.esTreeNodeToTSNodeMap?.get(body.left);
+            const tsLeftProp = services.esTreeNodeToTSNodeMap?.get(left);
 
-            const tsRightProp = services.esTreeNodeToTSNodeMap?.get(body.right);
+            const tsRightProp = services.esTreeNodeToTSNodeMap?.get(right);
 
             if (tsLeftProp !== undefined && tsRightProp !== undefined) {
               const leftPropType = checker.getTypeAtLocation(tsLeftProp);
@@ -217,7 +251,7 @@ export const preferArrSum: TSESLint.RuleModule<MessageIds, Options> = {
           // Generate mapper function
           const mapperParam = param1.name;
 
-          const mapper = body.left.computed
+          const mapper = left.computed
             ? `${mapperParam} => ${mapperParam}['${mut_propName}']`
             : `${mapperParam} => ${mapperParam}.${mut_propName}`;
 
@@ -235,7 +269,10 @@ export const preferArrSum: TSESLint.RuleModule<MessageIds, Options> = {
         const hasArrImport = namedImports.includes('Arr');
 
         for (const [index, nodeInfo] of mut_nodesToFix.entries()) {
-          const arrayText = sourceCode.getText(nodeInfo.arrayExpression);
+          const arrayText = toArgumentText(
+            nodeInfo.arrayExpression,
+            sourceCode,
+          );
 
           context.report({
             node: nodeInfo.node,

package/src/rules/prefer-arr-sum.test.mts

@@ -169,3 +169,100 @@ describe('prefer-arr-sum', () => {
     ],
   });
 }, 20000);
+
+describe('prefer-arr-sum through type wrappers', () => {
+  tester.run('prefer-arr-sum', preferArrSum, {
+    valid: [
+      {
+        name: 'strings cast to numbers are concatenated, not summed',
+        code: dedent`
+          declare const xs: readonly string[];
+          const sum = (xs as unknown as readonly number[]).reduce(
+            (a, b) => a + b,
+            0,
+          );
+        `,
+      },
+      {
+        name: 'a string property cast to number',
+        code: dedent`
+          declare const xs: readonly Readonly<{ n: string }>[];
+          const sum = xs.reduce(
+            (a, b) => (a.n as unknown as number) + (b.n as unknown as number),
+            0,
+          );
+        `,
+      },
+      {
+        name: 'a computed `reduce` is some other method',
+        code: dedent`
+          declare const xs: readonly number[];
+          declare const reduce: 'reduce';
+          const sum = xs[reduce]((a, b) => a + b, 0);
+        `,
+      },
+    ],
+    invalid: [
+      {
+        name: 'the initial value or an operand wrapped',
+        code: dedent`
+          import { Arr } from 'ts-data-forge';
+          declare const xs: readonly number[];
+          const a = xs.reduce((a, b) => a + b, 0 as number);
+          const b = xs.reduce((a, b) => a + (b satisfies number), 0);
+          const c = xs!.reduce((a, b) => a! + b, 0);
+        `,
+        output: dedent`
+          import { Arr } from 'ts-data-forge';
+          declare const xs: readonly number[];
+          const a = Arr.sum(xs);
+          const b = Arr.sum(xs);
+          const c = Arr.sum(xs!);
+        `,
+        errors: [
+          { messageId: 'useArrSum' },
+          { messageId: 'useArrSum' },
+          { messageId: 'useArrSum' },
+        ],
+      },
+      {
+        name: 'a property read through wrappers',
+        code: dedent`
+          import { Arr } from 'ts-data-forge';
+          declare const xs: readonly Readonly<{ n: number }>[];
+          const sum = xs.reduce((a, b) => (a.n satisfies number) + b!.n, 0);
+        `,
+        output: dedent`
+          import { Arr } from 'ts-data-forge';
+          declare const xs: readonly Readonly<{ n: number }>[];
+          const sum = Arr.sumBy(xs, a => a.n);
+        `,
+        errors: [{ messageId: 'useArrSumBy' }],
+      },
+    ],
+  });
+}, 20000);
+
+describe('prefer-arr-sum with parenthesized operands', () => {
+  tester.run('prefer-arr-sum', preferArrSum, {
+    valid: [],
+    invalid: [
+      {
+        name: 'a sequence array keeps its parentheses',
+        code: dedent`
+          import { Arr } from 'ts-data-forge';
+          declare const xs: readonly number[];
+          declare const log: () => void;
+          const sum = (log(), xs).reduce((a, b) => a + b, 0);
+        `,
+        output: dedent`
+          import { Arr } from 'ts-data-forge';
+          declare const xs: readonly number[];
+          declare const log: () => void;
+          const sum = Arr.sum((log(), xs));
+        `,
+        errors: [{ messageId: 'useArrSum' }],
+      },
+    ],
+  });
+}, 20000);