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

package/src/rules/prefer-arr-is-min-length-array.mts

@@ -1,8 +1,11 @@
-import { type TSESLint, type TSESTree } from '@typescript-eslint/utils';
+import type { TSESLint, TSESTree } from '@typescript-eslint/utils';
 import {
+  asLengthAccess,
+  isArrayOrTupleExpression,
   isIntegerLiteralOrConstant,
-  isLengthAccess,
   isPartOfBoundedLengthCheck,
+  skipTypeWrappers,
+  toArgumentText,
 } from './ast-utils.mjs';
 import {
   buildImportFixes,
@@ -63,12 +66,15 @@ export const preferArrIsMinLengthArray: TSESLint.RuleModule<
         // xs.length >= n  or  n <= xs.length
         const isLengthOnLeft = node.operator === '>=';
 
-        const lengthSide = node[isLengthOnLeft ? 'left' : 'right'];
+        // Both sides are read through type wrappers.
+        const lengthSide = asLengthAccess(
+          node[isLengthOnLeft ? 'left' : 'right'],
+        );
 
         const valueSide = node[isLengthOnLeft ? 'right' : 'left'];
 
         // Check if lengthSide is accessing .length
-        if (!isLengthAccess(lengthSide)) {
+        if (lengthSide === undefined) {
           return;
         }
 
@@ -77,36 +83,19 @@ export const preferArrIsMinLengthArray: TSESLint.RuleModule<
           return;
         }
 
-        // lengthSide is MemberExpression accessing .length
         const arrayExpression = lengthSide.object;
 
         // Check if arrayExpression is actually an array type
-        if (services?.program !== undefined && services.program !== null) {
-          const checker = services.program.getTypeChecker();
-
-          const tsNode = services.esTreeNodeToTSNodeMap?.get(arrayExpression);
-
-          if (tsNode !== undefined) {
-            const type = checker.getTypeAtLocation(tsNode);
-
-            // Check if it's an array type or tuple type
-            const isArrayType =
-              checker.isArrayType(type) || checker.isTupleType(type);
-
-            if (!isArrayType) {
-              return;
-            }
-          } else {
-            return;
-          }
-        } else {
+        if (!isArrayOrTupleExpression(services, arrayExpression)) {
           return;
         }
 
         mut_nodesToFix.push({
           node,
           arrayExpression,
-          lengthExpression: valueSide,
+          // The literal or constant itself: a wrapper such as `as number`
+          // would only widen the length the guard narrows to.
+          lengthExpression: skipTypeWrappers(valueSide),
         });
       },
       'Program:exit': () => {
@@ -118,7 +107,7 @@ export const preferArrIsMinLengthArray: TSESLint.RuleModule<
           index,
           { node, arrayExpression, lengthExpression },
         ] of mut_nodesToFix.entries()) {
-          const arrayText = sourceCode.getText(arrayExpression);
+          const arrayText = toArgumentText(arrayExpression, sourceCode);
 
           const lengthText = sourceCode.getText(lengthExpression);
 

package/src/rules/prefer-arr-is-min-length-array.test.mts

@@ -200,3 +200,73 @@ describe('prefer-arr-is-min-length-array', () => {
     ],
   });
 }, 20000);
+
+describe('prefer-arr-is-min-length-array through type wrappers', () => {
+  tester.run('prefer-arr-is-min-length-array', preferArrIsMinLengthArray, {
+    valid: [
+      {
+        name: 'a computed index named `length` is not the length',
+        code: dedent`
+          declare const xs: readonly number[];
+          declare const length: number;
+          const ok = xs[length] >= 2;
+        `,
+      },
+      {
+        name: 'the lower half of a bounded pair whose other half is wrapped',
+        code: dedent`
+          declare const xs: readonly number[];
+          const ok = xs.length >= 1 && (xs as readonly number[]).length <= 3;
+        `,
+      },
+    ],
+    invalid: [
+      {
+        name: 'the length or the bound wrapped',
+        code: dedent`
+          import { Arr } from 'ts-data-forge';
+          declare const xs: readonly number[];
+          const a = (xs.length satisfies number) >= 2;
+          const b = xs.length >= (2 as number);
+          const c = (3 satisfies number) <= xs.length!;
+        `,
+        output: dedent`
+          import { Arr } from 'ts-data-forge';
+          declare const xs: readonly number[];
+          const a = Arr.isMinLengthArray(2, xs);
+          const b = Arr.isMinLengthArray(2, xs);
+          const c = Arr.isMinLengthArray(3, xs);
+        `,
+        errors: [
+          { messageId: 'useIsMinLengthArray' },
+          { messageId: 'useIsMinLengthArray' },
+          { messageId: 'useIsMinLengthArray' },
+        ],
+      },
+    ],
+  });
+}, 20000);
+
+describe('prefer-arr-is-min-length-array with parenthesized operands', () => {
+  tester.run('prefer-arr-is-min-length-array', preferArrIsMinLengthArray, {
+    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 ok = (log(), xs).length >= 2;
+        `,
+        output: dedent`
+          import { Arr } from 'ts-data-forge';
+          declare const xs: readonly number[];
+          declare const log: () => void;
+          const ok = Arr.isMinLengthArray(2, (log(), xs));
+        `,
+        errors: [{ messageId: 'useIsMinLengthArray' }],
+      },
+    ],
+  });
+}, 20000);

package/src/rules/prefer-arr-is-non-empty.mts

@@ -3,6 +3,12 @@ import {
   type TSESLint,
   type TSESTree,
 } from '@typescript-eslint/utils';
+import {
+  asLengthAccess,
+  isArrayOrTupleExpression,
+  skipTypeWrappers,
+  toArgumentText,
+} from './ast-utils.mjs';
 import {
   buildImportFixes,
   getNamedImports,
@@ -51,15 +57,18 @@ export const preferArrIsNonEmpty: TSESLint.RuleModule<MessageIds, Options> = {
 
         const isLengthOnLeft = node.operator === '>';
 
-        const lengthSide = node[isLengthOnLeft ? 'left' : 'right'];
+        // Both sides are read through type wrappers.
+        const lengthSide = asLengthAccess(
+          node[isLengthOnLeft ? 'left' : 'right'],
+        );
 
-        const numberSide = node[isLengthOnLeft ? 'right' : 'left'];
+        const numberSide = skipTypeWrappers(
+          node[isLengthOnLeft ? 'right' : 'left'],
+        );
 
         // Check if one side is `.length` and the other is 0
         if (
-          lengthSide.type !== AST_NODE_TYPES.MemberExpression ||
-          lengthSide.property.type !== AST_NODE_TYPES.Identifier ||
-          lengthSide.property.name !== 'length' ||
+          lengthSide === undefined ||
           numberSide.type !== AST_NODE_TYPES.Literal ||
           numberSide.value !== 0
         ) {
@@ -69,25 +78,7 @@ export const preferArrIsNonEmpty: TSESLint.RuleModule<MessageIds, Options> = {
         const arrayExpression = lengthSide.object;
 
         // Check if arrayExpression is actually an array type
-        if (services?.program !== undefined && services.program !== null) {
-          const checker = services.program.getTypeChecker();
-
-          const tsNode = services.esTreeNodeToTSNodeMap?.get(arrayExpression);
-
-          if (tsNode !== undefined) {
-            const type = checker.getTypeAtLocation(tsNode);
-
-            // Check if it's an array type or tuple type
-            const isArrayType =
-              checker.isArrayType(type) || checker.isTupleType(type);
-
-            if (!isArrayType) {
-              return;
-            }
-          } else {
-            return;
-          }
-        } else {
+        if (!isArrayOrTupleExpression(services, arrayExpression)) {
           return;
         }
 
@@ -105,7 +96,7 @@ export const preferArrIsNonEmpty: TSESLint.RuleModule<MessageIds, Options> = {
           index,
           { node, arrayExpression },
         ] of mut_nodesToFix.entries()) {
-          const arrayText = sourceCode.getText(arrayExpression);
+          const arrayText = toArgumentText(arrayExpression, sourceCode);
 
           const originalText = sourceCode.getText(node);
 

package/src/rules/prefer-arr-is-non-empty.test.mts

@@ -88,3 +88,82 @@ describe('prefer-arr-is-non-empty', () => {
     ],
   });
 }, 20000);
+
+describe('prefer-arr-is-non-empty through type wrappers', () => {
+  tester.run('prefer-arr-is-non-empty', preferArrIsNonEmpty, {
+    valid: [
+      {
+        name: 'a type that says `0` is not the value `0`: only a literal is read through its wrapper',
+        code: dedent`
+          declare const xs: readonly number[];
+          declare const n: number;
+          const a = xs.length > (n as 0);
+        `,
+      },
+      {
+        name: 'a computed index named `length` is not the length',
+        code: dedent`
+          declare const xs: readonly number[];
+          declare const length: number;
+          const a = xs[length] > 0;
+          const b = xs[length]! > 0;
+        `,
+      },
+      {
+        name: 'a string cast to an array',
+        code: dedent`
+          declare const s: string;
+          const ok = (s as unknown as readonly string[]).length > 0;
+        `,
+      },
+    ],
+    invalid: [
+      {
+        name: 'the length or the zero wrapped',
+        code: dedent`
+          import { Arr } from 'ts-data-forge';
+          declare const xs: readonly number[];
+          const a = (xs.length satisfies number) > 0;
+          const b = xs.length > (0 as number);
+          const c = 0 < xs.length!;
+        `,
+        output: dedent`
+          import { Arr } from 'ts-data-forge';
+          declare const xs: readonly number[];
+          const a = Arr.isNonEmpty(xs);
+          const b = Arr.isNonEmpty(xs);
+          const c = Arr.isNonEmpty(xs);
+        `,
+        errors: [
+          { messageId: 'useIsNonEmpty' },
+          { messageId: 'useIsNonEmpty' },
+          { messageId: 'useIsNonEmpty' },
+        ],
+      },
+    ],
+  });
+}, 20000);
+
+describe('prefer-arr-is-non-empty with parenthesized operands', () => {
+  tester.run('prefer-arr-is-non-empty', preferArrIsNonEmpty, {
+    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 ok = (log(), xs).length > 0;
+        `,
+        output: dedent`
+          import { Arr } from 'ts-data-forge';
+          declare const xs: readonly number[];
+          declare const log: () => void;
+          const ok = Arr.isNonEmpty((log(), xs));
+        `,
+        errors: [{ messageId: 'useIsNonEmpty' }],
+      },
+    ],
+  });
+}, 20000);

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

@@ -4,8 +4,13 @@ import {
   type TSESTree,
 } from '@typescript-eslint/utils';
 import { Arr } from 'ts-data-forge';
-import { type FixedLengthTuple } from 'ts-type-forge';
+import type { FixedLengthTuple } from 'ts-type-forge';
 import * as ts from 'typescript';
+import {
+  skipTypeWrappers,
+  toArgumentText,
+  typeWrapperLayers,
+} from './ast-utils.mjs';
 import {
   buildImportFixes,
   getNamedImports,
@@ -135,10 +140,10 @@ type Splice = Readonly<{ range: FixedLengthTuple<2, number>; text: string }>;
  *   fourth parameter (the whole array) having no counterpart in `scan`.
  *
  * `acc.at(-1)` is typed `T | undefined` while `scan`'s accumulator is `S`, so a
- * `?? fallback` guarding it becomes redundant after the fix. It is left in
- * place rather than removed: it evaluates identically either way, and deciding
- * that it is dead needs to know that `S` excludes `undefined`, which is type
- * information this rule does not take.
+ * `?? fallback` guarding it becomes redundant after the fix. It is removed only
+ * when type information shows that neither the seed nor the appended value can
+ * be nullish — asked of each both as written and under any `as` / `!`, since
+ * `[init!]` may still hold `undefined` — and kept otherwise.
  *
  * ## What is not reported
  *
@@ -147,7 +152,8 @@ type Splice = Readonly<{ range: FixedLengthTuple<2, number>; text: string }>;
  * `scan` hands its callback the accumulated value and the element, never the
  * prefix, so such a callback is not one it can express.
  *
- * The array has to be spelled the same way in the `map` and in the `slice`.
+ * The array has to be spelled the same way in the `map` and in the `slice`,
+ * type wrappers aside (`(xs as readonly T[]).slice(…)` slices `xs`).
  * Deciding that two differently written expressions denote one array needs type
  * information and would still be a guess about aliasing.
  */
@@ -278,8 +284,14 @@ export const preferArrScan: TSESLint.RuleModule<MessageIds, Options> = {
       // which a seeded accumulator never does. So once the value `scan` carries
       // is known not to be nullish, a `?? fallback` guarding the read is dead
       // and the fix takes it with the read — leaving it would hand the author an
-      // unnecessary condition that no rule can fix for them.
-      const carriesNullish = isNullish(seed) || isNullish(element);
+      // unnecessary condition that no rule can fix for them. Every layer of
+      // type wrappers is asked (see typeWrapperLayers): the value under an
+      // `as` / `!` is what `scan` carries at run time (`[init!]` may still
+      // hold `undefined`), and a wider type a wrapper states is the author
+      // saying it may be nullish.
+      const carriesNullish = [seed, element].some((node) =>
+        typeWrapperLayers(node).some(isNullish),
+      );
 
       const mut_lastReads: Splice[] = [];
 
@@ -331,12 +343,22 @@ export const preferArrScan: TSESLint.RuleModule<MessageIds, Options> = {
         mut_lastReads,
       );
 
-      const arrayText = sourceCode.getText(
+      const arrayText = toArgumentText(
         // eslint-disable-next-line total-functions/no-unsafe-type-assertion
         (call.callee as TSESTree.MemberExpression).object,
+        sourceCode,
       );
 
-      return `Arr.scan(${arrayText}, (${parameterText}) => ${elementText}, ${sourceCode.getText(seed)})`;
+      // A node's text never includes the parentheses the source put around it:
+      // an object literal would open a block body, and a sequence would run on
+      // into the next argument.
+      const bodyText =
+        elementText.trimStart().startsWith('{') ||
+        element.type === AST_NODE_TYPES.SequenceExpression
+          ? `(${elementText})`
+          : elementText;
+
+      return `Arr.scan(${arrayText}, (${parameterText}) => ${bodyText}, ${toArgumentText(seed, sourceCode)})`;
     };
 
     /**
@@ -397,7 +419,11 @@ export const preferArrScan: TSESLint.RuleModule<MessageIds, Options> = {
 
         const methodName = node.callee.property.name;
 
-        const arrayText = sourceCode.getText(node.callee.object);
+        // Through type wrappers, so that `(xs as readonly T[]).slice(…)` is
+        // seen slicing the `xs` being mapped.
+        const arrayText = sourceCode.getText(
+          skipTypeWrappers(node.callee.object),
+        );
 
         if (SLICING_METHODS.has(methodName)) {
           mut_slices.push({ call: node, arrayText });
@@ -651,9 +677,13 @@ const appendsToItsAccumulator = (
         : undefined;
 
   const target =
-    spelling?.type === AST_NODE_TYPES.SpreadElement
-      ? spelling.argument
-      : spelling;
+    spelling === undefined || spelling === null
+      ? undefined
+      : skipTypeWrappers(
+          spelling.type === AST_NODE_TYPES.SpreadElement
+            ? spelling.argument
+            : spelling,
+        );
 
   return (
     target?.type === AST_NODE_TYPES.Identifier &&
@@ -690,13 +720,17 @@ const accumulationOf = (
 
     const [spread, element] = body.elements;
 
+    const spreadTarget =
+      spread?.type === AST_NODE_TYPES.SpreadElement
+        ? skipTypeWrappers(spread.argument)
+        : undefined;
+
     return element === null ||
       element.type === AST_NODE_TYPES.SpreadElement ||
-      spread?.type !== AST_NODE_TYPES.SpreadElement ||
-      spread.argument.type !== AST_NODE_TYPES.Identifier ||
-      spread.argument.name !== accumulatorParam.name
+      spreadTarget?.type !== AST_NODE_TYPES.Identifier ||
+      spreadTarget.name !== accumulatorParam.name
       ? undefined
-      : { accumulatorParam, accumulatorRef: spread.argument, element };
+      : { accumulatorParam, accumulatorRef: spreadTarget, element };
   }
 
   // `Arr.toPushed(acc, ELEMENT)`, matched on the method name as the rest of
@@ -714,7 +748,9 @@ const accumulationOf = (
       return undefined;
     }
 
-    const [target, element] = body.arguments;
+    const [wrappedTarget, element] = body.arguments;
+
+    const target = skipTypeWrappers(wrappedTarget);
 
     return element.type === AST_NODE_TYPES.SpreadElement ||
       target.type !== AST_NODE_TYPES.Identifier ||

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' }],
+      },
+    ],
+  });
+});