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

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

@@ -60,3 +60,43 @@ ruleTester.run('prefer-arr-is-array', preferArrIsArray, {
     },
   ],
 });
+
+describe('prefer-arr-is-array through type wrappers', () => {
+  ruleTester.run('prefer-arr-is-array', preferArrIsArray, {
+    valid: [],
+    invalid: [
+      {
+        name: 'Array reached through `as`',
+        code: dedent`
+          import { Arr } from 'ts-data-forge';
+          const result = (Array as ArrayConstructor).isArray(value);
+        `,
+        output: dedent`
+          import { Arr } from 'ts-data-forge';
+          const result = Arr.isArray(value);
+        `,
+        errors: [{ messageId: 'useArrIsArray' }],
+      },
+    ],
+  });
+});
+
+describe('prefer-arr-is-array with parenthesized operands', () => {
+  ruleTester.run('prefer-arr-is-array', preferArrIsArray, {
+    valid: [],
+    invalid: [
+      {
+        name: 'a parenthesized callee',
+        code: dedent`
+          import { Arr } from 'ts-data-forge';
+          const result = (Array.isArray)(value);
+        `,
+        output: dedent`
+          import { Arr } from 'ts-data-forge';
+          const result = (Arr.isArray)(value);
+        `,
+        errors: [{ messageId: 'useArrIsArray' }],
+      },
+    ],
+  });
+});

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

@@ -1,5 +1,10 @@
-import { type TSESLint, type TSESTree } from '@typescript-eslint/utils';
-import { parseLengthComparison } from './ast-utils.mjs';
+import type { TSESLint, TSESTree } from '@typescript-eslint/utils';
+import {
+  isArrayOrTupleExpression,
+  isSameArrayText,
+  parseLengthComparison,
+  toArgumentText,
+} from './ast-utils.mjs';
 import {
   buildImportFixes,
   getNamedImports,
@@ -47,20 +52,24 @@ export const preferArrIsBoundedLengthArray: TSESLint.RuleModule<
     return {
       LogicalExpression: (node) => {
         // Only `a && b` can encode a `min && max` length range.
-        if (node.operator !== '&&') return;
+        if (node.operator !== '&&') {
+          return;
+        }
 
         const left = parseLengthComparison(node.left, sourceCode);
 
         const right = parseLengthComparison(node.right, sourceCode);
 
-        if (left === undefined || right === undefined) return;
+        if (left === undefined || right === undefined) {
+          return;
+        }
 
         // Need one lower bound and one upper bound on the same array.
-        if (left.kind === right.kind) return;
+        if (left.kind === right.kind) {
+          return;
+        }
 
-        if (
-          sourceCode.getText(left.array) !== sourceCode.getText(right.array)
-        ) {
+        if (!isSameArrayText(left.array, right.array, sourceCode)) {
           return;
         }
 
@@ -71,23 +80,10 @@ export const preferArrIsBoundedLengthArray: TSESLint.RuleModule<
         const arrayExpression = min.array;
 
         // 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, min.array) ||
+          !isArrayOrTupleExpression(services, max.array)
+        ) {
           return;
         }
 
@@ -107,7 +103,7 @@ export const preferArrIsBoundedLengthArray: TSESLint.RuleModule<
           index,
           { node, arrayExpression, minExpression, maxExpression },
         ] of mut_nodesToFix.entries()) {
-          const arrayText = sourceCode.getText(arrayExpression);
+          const arrayText = toArgumentText(arrayExpression, sourceCode);
 
           const minText = sourceCode.getText(minExpression);
 

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

@@ -152,3 +152,71 @@ describe('prefer-arr-is-bounded-length-array', () => {
     },
   );
 }, 20000);
+
+describe('prefer-arr-is-bounded-length-array through type wrappers', () => {
+  tester.run(
+    'prefer-arr-is-bounded-length-array',
+    preferArrIsBoundedLengthArray,
+    {
+      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] >= 1 && xs.length <= 3;
+          `,
+        },
+      ],
+      invalid: [
+        {
+          name: 'the array, the length and the bounds wrapped',
+          code: dedent`
+            import { Arr } from 'ts-data-forge';
+            declare const xs: readonly number[];
+            const a = xs.length >= 1 && (xs as readonly number[]).length <= 3;
+            const b = (xs.length satisfies number) >= (1 as number) && xs!.length <= 3;
+          `,
+          output: dedent`
+            import { Arr } from 'ts-data-forge';
+            declare const xs: readonly number[];
+            const a = Arr.isBoundedLengthArray(1, 3, xs);
+            const b = Arr.isBoundedLengthArray(1, 3, xs);
+          `,
+          errors: [
+            { messageId: 'useIsBoundedLengthArray' },
+            { messageId: 'useIsBoundedLengthArray' },
+          ],
+        },
+      ],
+    },
+  );
+}, 20000);
+
+describe('prefer-arr-is-bounded-length-array with parenthesized operands', () => {
+  tester.run(
+    'prefer-arr-is-bounded-length-array',
+    preferArrIsBoundedLengthArray,
+    {
+      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 >= 1 && (log(), xs).length <= 3;
+          `,
+          output: dedent`
+            import { Arr } from 'ts-data-forge';
+            declare const xs: readonly number[];
+            declare const log: () => void;
+            const ok = Arr.isBoundedLengthArray(1, 3, (log(), xs));
+          `,
+          errors: [{ messageId: 'useIsBoundedLengthArray' }],
+        },
+      ],
+    },
+  );
+}, 20000);

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

@@ -1,10 +1,11 @@
+import type { TSESLint, TSESTree } from '@typescript-eslint/utils';
 import {
-  AST_NODE_TYPES,
-  type TSESLint,
-  type TSESTree,
-} from '@typescript-eslint/utils';
-import { type DeepReadonly } from 'ts-type-forge';
-import { isIntegerLiteralOrConstant } from './ast-utils.mjs';
+  asLengthAccess,
+  isArrayOrTupleExpression,
+  isIntegerLiteralOrConstant,
+  skipTypeWrappers,
+  toArgumentText,
+} from './ast-utils.mjs';
 import {
   buildImportFixes,
   getNamedImports,
@@ -52,49 +53,43 @@ export const preferArrIsFixedLengthArray: TSESLint.RuleModule<
     return {
       BinaryExpression: (node) => {
         // Check for `xs.length === n` or `n === xs.length` or `xs.length !== n`
-        if (node.operator !== '===' && node.operator !== '!==') return;
+        if (node.operator !== '===' && node.operator !== '!==') {
+          return;
+        }
 
         const isNegated = node.operator === '!==';
 
-        const isLengthOnLeft = isLengthAccess(node.left);
+        // Both sides are read through type wrappers.
+        const leftLength = asLengthAccess(node.left);
+
+        const isLengthOnLeft = leftLength !== undefined;
 
-        const lengthSide = node[isLengthOnLeft ? 'left' : 'right'];
+        const lengthSide = leftLength ?? asLengthAccess(node.right);
 
         const valueSide = node[isLengthOnLeft ? 'right' : 'left'];
 
-        if (!isLengthAccess(lengthSide)) return;
+        if (lengthSide === undefined) {
+          return;
+        }
 
         // Only match integer literals or const variables initialized with integer literals
-        if (!isIntegerLiteralOrConstant(valueSide, sourceCode)) return;
+        if (!isIntegerLiteralOrConstant(valueSide, sourceCode)) {
+          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),
           isNegated,
         });
       },
@@ -107,7 +102,7 @@ export const preferArrIsFixedLengthArray: TSESLint.RuleModule<
           index,
           { node, arrayExpression, lengthExpression, isNegated },
         ] of mut_nodesToFix.entries()) {
-          const arrayText = sourceCode.getText(arrayExpression);
+          const arrayText = toArgumentText(arrayExpression, sourceCode);
 
           const lengthText = sourceCode.getText(lengthExpression);
 
@@ -140,10 +135,3 @@ export const preferArrIsFixedLengthArray: TSESLint.RuleModule<
   },
   defaultOptions: [],
 } as const;
-
-const isLengthAccess = (
-  node: DeepReadonly<TSESTree.Expression>,
-): node is TSESTree.MemberExpression =>
-  node.type === AST_NODE_TYPES.MemberExpression &&
-  node.property.type === AST_NODE_TYPES.Identifier &&
-  node.property.name === 'length';

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

@@ -212,3 +212,66 @@ describe('prefer-arr-is-fixed-length-array', () => {
     ],
   });
 }, 20000);
+
+describe('prefer-arr-is-fixed-length-array through type wrappers', () => {
+  tester.run('prefer-arr-is-fixed-length-array', preferArrIsFixedLengthArray, {
+    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] === 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 === (3 satisfies number);
+          const b = (xs.length as number) !== 3;
+          const c = (2 as number) === xs.length;
+        `,
+        output: dedent`
+          import { Arr } from 'ts-data-forge';
+          declare const xs: readonly number[];
+          const a = Arr.isFixedLengthArray(3, xs);
+          const b = !Arr.isFixedLengthArray(3, xs);
+          const c = Arr.isFixedLengthArray(2, xs);
+        `,
+        errors: [
+          { messageId: 'useIsFixedLengthArray' },
+          { messageId: 'useIsFixedLengthArray' },
+          { messageId: 'useIsFixedLengthArray' },
+        ],
+      },
+    ],
+  });
+}, 20000);
+
+describe('prefer-arr-is-fixed-length-array with parenthesized operands', () => {
+  tester.run('prefer-arr-is-fixed-length-array', preferArrIsFixedLengthArray, {
+    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.isFixedLengthArray(2, (log(), xs));
+        `,
+        errors: [{ messageId: 'useIsFixedLengthArray' }],
+      },
+    ],
+  });
+}, 20000);

package/src/rules/prefer-arr-is-max-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,
@@ -50,53 +53,49 @@ export const preferArrIsMaxLengthArray: TSESLint.RuleModule<
     return {
       BinaryExpression: (node) => {
         // Check for `xs.length <= n` or `n >= xs.length`
-        if (node.operator !== '>=' && node.operator !== '<=') return;
+        if (node.operator !== '>=' && node.operator !== '<=') {
+          return;
+        }
 
         // Defer to `prefer-arr-is-bounded-length-array` when this comparison is
         // the upper bound of a `min && max` pair on the same array.
-        if (isPartOfBoundedLengthCheck(node, sourceCode)) return;
+        if (isPartOfBoundedLengthCheck(node, sourceCode)) {
+          return;
+        }
 
         // 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)) return;
+        if (lengthSide === undefined) {
+          return;
+        }
 
         // Only match integer literals or const variables initialized with integer literals
-        if (!isIntegerLiteralOrConstant(valueSide, sourceCode)) return;
+        if (!isIntegerLiteralOrConstant(valueSide, sourceCode)) {
+          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': () => {
@@ -108,7 +107,7 @@ export const preferArrIsMaxLengthArray: 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-max-length-array.test.mts

@@ -186,3 +186,70 @@ describe('prefer-arr-is-max-length-array', () => {
     ],
   });
 }, 20000);
+
+describe('prefer-arr-is-max-length-array through type wrappers', () => {
+  tester.run('prefer-arr-is-max-length-array', preferArrIsMaxLengthArray, {
+    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 upper half of a bounded pair whose other half is wrapped',
+        code: dedent`
+          declare const xs: readonly number[];
+          const ok = xs!.length >= 1 && xs.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);
+        `,
+        output: dedent`
+          import { Arr } from 'ts-data-forge';
+          declare const xs: readonly number[];
+          const a = Arr.isMaxLengthArray(2, xs);
+          const b = Arr.isMaxLengthArray(2, xs);
+        `,
+        errors: [
+          { messageId: 'useIsMaxLengthArray' },
+          { messageId: 'useIsMaxLengthArray' },
+        ],
+      },
+    ],
+  });
+}, 20000);
+
+describe('prefer-arr-is-max-length-array with parenthesized operands', () => {
+  tester.run('prefer-arr-is-max-length-array', preferArrIsMaxLengthArray, {
+    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.isMaxLengthArray(2, (log(), xs));
+        `,
+        errors: [{ messageId: 'useIsMaxLengthArray' }],
+      },
+    ],
+  });
+}, 20000);

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,
@@ -50,53 +53,49 @@ export const preferArrIsMinLengthArray: TSESLint.RuleModule<
     return {
       BinaryExpression: (node) => {
         // Check for `xs.length >= n` or `n <= xs.length`
-        if (node.operator !== '>=' && node.operator !== '<=') return;
+        if (node.operator !== '>=' && node.operator !== '<=') {
+          return;
+        }
 
         // Defer to `prefer-arr-is-bounded-length-array` when this comparison is
         // the lower bound of a `min && max` pair on the same array.
-        if (isPartOfBoundedLengthCheck(node, sourceCode)) return;
+        if (isPartOfBoundedLengthCheck(node, sourceCode)) {
+          return;
+        }
 
         // 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)) return;
+        if (lengthSide === undefined) {
+          return;
+        }
 
         // Only match integer literals or const variables initialized with integer literals
-        if (!isIntegerLiteralOrConstant(valueSide, sourceCode)) return;
+        if (!isIntegerLiteralOrConstant(valueSide, sourceCode)) {
+          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': () => {
@@ -108,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);