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

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,
@@ -45,19 +51,24 @@ export const preferArrIsNonEmpty: TSESLint.RuleModule<MessageIds, Options> = {
     return {
       BinaryExpression: (node) => {
         // Check for `xs.length > 0` or `0 < xs.length`
-        if (node.operator !== '>' && node.operator !== '<') return;
+        if (node.operator !== '>' && node.operator !== '<') {
+          return;
+        }
 
         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
         ) {
@@ -67,23 +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;
         }
 
@@ -101,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.
  */
@@ -190,7 +196,9 @@ export const preferArrScan: TSESLint.RuleModule<MessageIds, Options> = {
     ): boolean => {
       const tsNode = services?.esTreeNodeToTSNodeMap?.get(node);
 
-      if (checker === undefined || tsNode === undefined) return true;
+      if (checker === undefined || tsNode === undefined) {
+        return true;
+      }
 
       const type = checker.getTypeAtLocation(tsNode);
 
@@ -227,14 +235,16 @@ export const preferArrScan: TSESLint.RuleModule<MessageIds, Options> = {
       // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
       accumulation: Accumulation,
     ): string | undefined => {
-      if (callback.async || callback.generator) return undefined;
+      if (callback.async || callback.generator) {
+        return undefined;
+      }
 
       // `reduce`'s fourth parameter is the whole array, which `scan` never
       // hands its callback; an annotation on the accumulator describes that
       // array, and would be wrong on `scan`'s value parameter.
       if (
         callback.params.length < 2 ||
-        callback.params.length > 3 ||
+        3 < callback.params.length ||
         callback.params.some(
           (param) =>
             param.type !== AST_NODE_TYPES.Identifier ||
@@ -266,14 +276,22 @@ export const preferArrScan: TSESLint.RuleModule<MessageIds, Options> = {
         (variable) => variable.name === accumulatorParam.name,
       );
 
-      if (accumulator === undefined) return undefined;
+      if (accumulator === undefined) {
+        return undefined;
+      }
 
       // `acc.at(-1)` is `T | undefined` only because `at` can go out of bounds,
       // 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[] = [];
 
@@ -281,13 +299,19 @@ export const preferArrScan: TSESLint.RuleModule<MessageIds, Options> = {
         const identifier = reference.identifier;
 
         // The `...acc` / `Arr.toPushed(acc, …)` target the rewrite drops.
-        if (identifier === accumulatorRef) continue;
+        if (identifier === accumulatorRef) {
+          continue;
+        }
 
-        if (identifier.type !== AST_NODE_TYPES.Identifier) return undefined;
+        if (identifier.type !== AST_NODE_TYPES.Identifier) {
+          return undefined;
+        }
 
         const lastRead = enclosingLastRead(identifier);
 
-        if (lastRead === undefined) return undefined;
+        if (lastRead === undefined) {
+          return undefined;
+        }
 
         const guard = carriesNullish ? undefined : nullishGuardAround(lastRead);
 
@@ -299,11 +323,15 @@ export const preferArrScan: TSESLint.RuleModule<MessageIds, Options> = {
 
       // Two reads inside one `?? ` — `acc.at(-1) ?? acc.at(-1)` — would give
       // ranges that contain one another, which no ordering of splices resolves.
-      if (overlaps(mut_lastReads)) return undefined;
+      if (overlaps(mut_lastReads)) {
+        return undefined;
+      }
 
       // With no read of the previous value this is a `map` with a seed rather
       // than a scan, and the accumulator parameter would be left unused.
-      if (mut_lastReads.length === 0) return undefined;
+      if (mut_lastReads.length === 0) {
+        return undefined;
+      }
 
       const parameterText = callback.params
         .map((param) => sourceCode.getText(param))
@@ -315,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)})`;
     };
 
     /**
@@ -333,7 +371,9 @@ export const preferArrScan: TSESLint.RuleModule<MessageIds, Options> = {
       // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
       callback: TSESTree.ArrowFunctionExpression | TSESTree.FunctionExpression,
     ): readonly TSESTree.Node[] | undefined => {
-      if (!Arr.isFixedLengthArray(2, callback.params)) return undefined;
+      if (!Arr.isFixedLengthArray(2, callback.params)) {
+        return undefined;
+      }
 
       const [elementParam, indexParam] = callback.params;
 
@@ -358,7 +398,9 @@ export const preferArrScan: TSESLint.RuleModule<MessageIds, Options> = {
         return undefined;
       }
 
-      if (elementVariable.references.length > 0) return undefined;
+      if (elementVariable.references.length > 0) {
+        return undefined;
+      }
 
       return indexVariable.references.map(
         (reference) => reference.identifier as TSESTree.Node,
@@ -377,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 });
@@ -395,11 +441,15 @@ export const preferArrScan: TSESLint.RuleModule<MessageIds, Options> = {
 
         switch (methodName) {
           case 'map': {
-            if (rest.length > 0) break;
+            if (rest.length > 0) {
+              break;
+            }
 
             const indexReads = indexReadsOf(callback);
 
-            if (indexReads === undefined) break;
+            if (indexReads === undefined) {
+              break;
+            }
 
             mut_candidates.push({
               call: node,
@@ -415,7 +465,9 @@ export const preferArrScan: TSESLint.RuleModule<MessageIds, Options> = {
             // Two arguments, so that the initial value is explicit: a `reduce`
             // without one starts from the first element and has no `scan`
             // spelling at all.
-            if (rest.length !== 1 || !appendsToItsAccumulator(callback)) break;
+            if (rest.length !== 1 || !appendsToItsAccumulator(callback)) {
+              break;
+            }
 
             const [initial] = rest;
 
@@ -483,7 +535,9 @@ export const preferArrScan: TSESLint.RuleModule<MessageIds, Options> = {
               ),
           );
 
-          if (rebuild === undefined) continue;
+          if (rebuild === undefined) {
+            continue;
+          }
 
           context.report({
             node: candidate.call,
@@ -605,7 +659,9 @@ const appendsToItsAccumulator = (
 ): boolean => {
   const [accumulatorParam] = callback.params;
 
-  if (accumulatorParam?.type !== AST_NODE_TYPES.Identifier) return false;
+  if (accumulatorParam?.type !== AST_NODE_TYPES.Identifier) {
+    return false;
+  }
 
   const { body } = callback;
 
@@ -621,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 &&
@@ -645,24 +705,32 @@ const accumulationOf = (
 ): Accumulation | undefined => {
   const [accumulatorParam] = callback.params;
 
-  if (accumulatorParam?.type !== AST_NODE_TYPES.Identifier) return undefined;
+  if (accumulatorParam?.type !== AST_NODE_TYPES.Identifier) {
+    return undefined;
+  }
 
   const { body } = callback;
 
   // `[...acc, ELEMENT]` — exactly one spread and one new value, since `scan`
   // appends exactly one per step.
   if (body.type === AST_NODE_TYPES.ArrayExpression) {
-    if (!Arr.isFixedLengthArray(2, body.elements)) return undefined;
+    if (!Arr.isFixedLengthArray(2, body.elements)) {
+      return undefined;
+    }
 
     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
@@ -680,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 ||