eslint-plugin-ts-data-forge 0.8.2 → 0.8.4

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'
         ) {
@@ -67,7 +74,10 @@ export const preferArrSum: TSESLint.RuleModule<MessageIds, Options> = {
 
         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 (
@@ -102,25 +112,43 @@ export const preferArrSum: TSESLint.RuleModule<MessageIds, Options> = {
           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(
@@ -128,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;
@@ -149,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 ||
@@ -168,25 +196,25 @@ 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'
           ) {
@@ -199,9 +227,9 @@ export const preferArrSum: TSESLint.RuleModule<MessageIds, Options> = {
 
           // 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);
@@ -223,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}`;
 
@@ -241,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);

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

@@ -5,6 +5,7 @@ import {
 } from '@typescript-eslint/utils';
 import { Arr } from 'ts-data-forge';
 import * as ts from 'typescript';
+import { skipTypeWrappers, typeWrapperLayers } from './ast-utils.mjs';
 import {
   buildImportFixes,
   getImportedLocalName,
@@ -87,15 +88,19 @@ export const preferArrUniq: TSESLint.RuleModule<MessageIds, Options> = {
         return;
       }
 
-      const arrayTsNode = getTsNode(arrayExpression);
+      // At every layer of type wrappers (see typeWrapperLayers).
+      const isPrimitiveArray = typeWrapperLayers(arrayExpression).every(
+        (layer) => {
+          const tsNode = getTsNode(layer);
 
-      if (arrayTsNode === undefined) {
-        return;
-      }
+          return (
+            tsNode !== undefined &&
+            isPrimitiveArrayType(checker, checker.getTypeAtLocation(tsNode))
+          );
+        },
+      );
 
-      if (
-        !isPrimitiveArrayType(checker, checker.getTypeAtLocation(arrayTsNode))
-      ) {
+      if (!isPrimitiveArray) {
         return;
       }
 
@@ -221,8 +226,11 @@ const mutatingMethods: ReadonlySet<string> = new Set([
  */
 const getSetSourceArray = (
   // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-  node: TSESTree.Node,
+  wrapped: TSESTree.Node,
 ): TSESTree.Expression | undefined => {
+  // `new Set(xs) as ReadonlySet<string>` is still `new Set(xs)`.
+  const node = skipTypeWrappers(wrapped);
+
   if (
     node.type !== AST_NODE_TYPES.NewExpression ||
     node.callee.type !== AST_NODE_TYPES.Identifier ||
@@ -348,15 +356,17 @@ const needsMutableResult = (
   // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
   node: TSESTree.Node,
 ): boolean => {
-  if (isUsedAsMutable(checker, getTsNode, node)) {
+  const outer = outermostTypePreservingWrapper(node);
+
+  if (isUsedAsMutable(checker, getTsNode, outer)) {
     return true;
   }
 
-  const parent = node.parent;
+  const parent = outer.parent;
 
   if (
     parent?.type !== AST_NODE_TYPES.VariableDeclarator ||
-    parent.init !== node ||
+    parent.init !== outer ||
     parent.id.type !== AST_NODE_TYPES.Identifier ||
     parent.id.typeAnnotation !== undefined
   ) {
@@ -369,11 +379,35 @@ const needsMutableResult = (
     variable?.references.some(
       (reference) =>
         reference.init !== true &&
-        isUsedAsMutable(checker, getTsNode, reference.identifier),
+        isUsedAsMutable(
+          checker,
+          getTsNode,
+          outermostTypePreservingWrapper(reference.identifier),
+        ),
     ) ?? false
   );
 };
 
+/**
+ * `node`, or the outermost `!` / `satisfies` around it. Neither changes the
+ * type the value is used at, so `Array.from(new Set(xs))!.push(4)` and
+ * `ys!.push(4)` still need a mutable array. An `as` does change it, and a
+ * readonly array may be cast to a mutable one, so the walk stops there.
+ */
+const outermostTypePreservingWrapper = (
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  node: TSESTree.Node,
+): TSESTree.Node => {
+  const { parent } = node;
+
+  return parent !== undefined &&
+    (parent.type === AST_NODE_TYPES.TSNonNullExpression ||
+      parent.type === AST_NODE_TYPES.TSSatisfiesExpression) &&
+    parent.expression === node
+    ? outermostTypePreservingWrapper(parent)
+    : node;
+};
+
 const isUsedAsMutable = (
   // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
   checker: ts.TypeChecker,

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

@@ -453,3 +453,74 @@ describe('prefer-arr-uniq', () => {
     ],
   });
 });
+
+describe('prefer-arr-uniq through type wrappers', () => {
+  tester.run('prefer-arr-uniq', preferArrUniq, {
+    valid: [],
+    invalid: [
+      {
+        name: 'a Set wrapped in `as` or `satisfies`',
+        code: dedent`
+          declare const xs: readonly string[];
+          const a = Array.from(new Set(xs) as ReadonlySet<string>);
+          const b = [...(new Set(xs) satisfies ReadonlySet<string>)];
+        `,
+        output: dedent`
+          import { Arr } from 'ts-data-forge';
+          declare const xs: readonly string[];
+          const a = Arr.uniq(xs);
+          const b = Arr.uniq(xs);
+        `,
+        errors: [{ messageId: 'useArrUniq' }, { messageId: 'useArrUniq' }],
+      },
+      {
+        name: 'only suggests when the result is mutated through `!`',
+        code: dedent`
+          const xs = [3, 1, 3];
+          Array.from(new Set(xs))!.push(4);
+        `,
+        output: null,
+        errors: [
+          {
+            messageId: 'useArrUniq',
+            suggestions: [
+              {
+                messageId: 'suggestArrUniq',
+                output: dedent`
+                  import { Arr } from 'ts-data-forge';
+                  const xs = [3, 1, 3];
+                  Arr.uniq(xs)!.push(4);
+                `,
+              },
+            ],
+          },
+        ],
+      },
+      {
+        name: 'only suggests when a variable initialized through `!` is mutated',
+        code: dedent`
+          const xs = [3, 1, 3];
+          const ys = Array.from(new Set(xs))!;
+          ys.push(4);
+        `,
+        output: null,
+        errors: [
+          {
+            messageId: 'useArrUniq',
+            suggestions: [
+              {
+                messageId: 'suggestArrUniq',
+                output: dedent`
+                  import { Arr } from 'ts-data-forge';
+                  const xs = [3, 1, 3];
+                  const ys = Arr.uniq(xs)!;
+                  ys.push(4);
+                `,
+              },
+            ],
+          },
+        ],
+      },
+    ],
+  });
+});

package/src/rules/prefer-as-int.mts

@@ -3,7 +3,8 @@ import {
   type TSESLint,
   type TSESTree,
 } from '@typescript-eslint/utils';
-import { type DeepReadonly } from 'ts-type-forge';
+import type { DeepReadonly } from 'ts-type-forge';
+import { toArgumentText } from './ast-utils.mjs';
 import { brandedNumberTypeNameToFunctionName } from './branded-number-types.mjs';
 import {
   buildImportFixes,
@@ -38,25 +39,32 @@ export const preferAsInt: TSESLint.RuleModule<MessageIds, Options> = {
     const tsDataForgeImport = getTsDataForgeImport(program);
 
     const mut_nodesToFix: {
-      node: TSESTree.TSAsExpression;
+      node: TSESTree.TSAsExpression | TSESTree.TSTypeAssertion;
       typeName: string;
       functionName: string;
     }[] = [];
 
-    return {
-      TSAsExpression: (node) => {
-        const typeInfo = getBrandedNumberTypeInfo(node.typeAnnotation);
-
-        if (typeInfo === undefined) {
-          return;
-        }
+    // `x as Int` and `<Int>x` are the same assertion.
+    const collect = (
+      // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+      node: TSESTree.TSAsExpression | TSESTree.TSTypeAssertion,
+    ): void => {
+      const typeInfo = getBrandedNumberTypeInfo(node.typeAnnotation);
+
+      if (typeInfo === undefined) {
+        return;
+      }
+
+      mut_nodesToFix.push({
+        node,
+        typeName: typeInfo.typeName,
+        functionName: typeInfo.functionName,
+      });
+    };
 
-        mut_nodesToFix.push({
-          node,
-          typeName: typeInfo.typeName,
-          functionName: typeInfo.functionName,
-        });
-      },
+    return {
+      TSAsExpression: collect,
+      TSTypeAssertion: collect,
       'Program:exit': () => {
         const namedImports = getNamedImports(tsDataForgeImport);
 
@@ -79,7 +87,7 @@ export const preferAsInt: TSESLint.RuleModule<MessageIds, Options> = {
                 functionName,
               },
               fix: (fixer) => {
-                const replacement = `${functionName}(${sourceCode.getText(node.expression)})`;
+                const replacement = `${functionName}(${toArgumentText(node.expression, sourceCode)})`;
 
                 // Add import only for the first node of this function and only if not already imported
                 const importFixes =

package/src/rules/prefer-as-int.test.mts

@@ -265,3 +265,54 @@ describe('prefer-as-int', () => {
     ],
   });
 }, 20000);
+
+describe('prefer-as-int through type wrappers', () => {
+  tester.run('prefer-as-int', preferAsInt, {
+    valid: [],
+    invalid: [
+      {
+        name: 'an angle-bracket assertion',
+        code: dedent`
+          import { asInt } from 'ts-data-forge';
+          declare const n: number;
+          const a = <Int>n;
+        `,
+        output: dedent`
+          import { asInt } from 'ts-data-forge';
+          declare const n: number;
+          const a = asInt(n);
+        `,
+        errors: [{ messageId: 'useBrandedNumberCastFunction' }],
+      },
+    ],
+  });
+}, 20000);
+
+describe('prefer-as-int with parenthesized operands', () => {
+  tester.run('prefer-as-int', preferAsInt, {
+    valid: [],
+    invalid: [
+      {
+        name: 'a sequence operand keeps its parentheses',
+        code: dedent`
+          import { asInt } from 'ts-data-forge';
+          declare const log: () => void;
+          declare const n: number;
+          const a = (log(), n) as Int;
+          const b = <Int>(log(), n);
+        `,
+        output: dedent`
+          import { asInt } from 'ts-data-forge';
+          declare const log: () => void;
+          declare const n: number;
+          const a = asInt((log(), n));
+          const b = asInt((log(), n));
+        `,
+        errors: [
+          { messageId: 'useBrandedNumberCastFunction' },
+          { messageId: 'useBrandedNumberCastFunction' },
+        ],
+      },
+    ],
+  });
+}, 20000);