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

package/src/rules/no-unnecessary-type-guard.test.mts

@@ -460,3 +460,103 @@ describe('no-unnecessary-type-guard', () => {
     ],
   });
 });
+
+describe('no-unnecessary-type-guard through type wrappers', () => {
+  tester.run('no-unnecessary-type-guard', noUnnecessaryTypeGuard, {
+    valid: [
+      {
+        name: 'isNullish on a value cast away from null',
+        code: dedent`
+          import { isNullish } from 'ts-data-forge';
+          declare const x: string | null | undefined;
+          const y = isNullish(x as string | undefined);
+        `,
+      },
+      {
+        name: 'isNonNullish on a value cast away from null',
+        code: dedent`
+          import { isNonNullish } from 'ts-data-forge';
+          declare const x: string | null | undefined;
+          const y = isNonNullish(x as string | undefined);
+        `,
+      },
+      {
+        name: 'isNonEmptyString on a string cast to NonEmptyString',
+        code: dedent`
+          import { type NonEmptyString } from 'ts-type-forge';
+          import { isNonEmptyString } from 'ts-data-forge';
+          declare const x: string | null | undefined;
+          const y = isNonEmptyString(x as NonEmptyString | null | undefined);
+        `,
+      },
+      {
+        name: 'isNull on a value whose `!` does not remove the null',
+        code: dedent`
+          import { isNull } from 'ts-data-forge';
+          declare const x: string | null;
+          const y = isNull(x!);
+        `,
+      },
+      {
+        name: 'isNull on a value widened to include null: the `as` is the author saying it may be null',
+        code: dedent`
+          import { isNull } from 'ts-data-forge';
+          declare const x: string;
+          const y = isNull(x as string | null);
+        `,
+      },
+      {
+        name: 'isNullish on a value widened to include null is not narrowed to isUndefined',
+        code: dedent`
+          import { isNullish } from 'ts-data-forge';
+          declare const x: string | undefined;
+          const y = isNullish(x as string | null | undefined);
+        `,
+      },
+    ],
+    invalid: [
+      {
+        name: 'isNonNullish on a value whose `!` does not remove the null',
+        code: dedent`
+          import { isNonNullish, isNotNull } from 'ts-data-forge';
+          declare const x: string | null;
+          const y = isNonNullish(x!);
+        `,
+        output: dedent`
+          import { isNonNullish, isNotNull } from 'ts-data-forge';
+          declare const x: string | null;
+          const y = isNotNull(x!);
+        `,
+        errors: [{ messageId: 'replaceTypeGuard' }],
+      },
+      {
+        name: 'isNull on a value widened to exclude null still, at every layer',
+        code: dedent`
+          import { isNull } from 'ts-data-forge';
+          declare const x: string;
+          const y = isNull(x as string | undefined);
+        `,
+        output: dedent`
+          import { isNull } from 'ts-data-forge';
+          declare const x: string;
+          const y = false;
+        `,
+        errors: [{ messageId: 'alwaysFalse' }],
+      },
+      {
+        name: 'isNullish replaced on the value under `satisfies`, keeping the wrapper',
+        code: dedent`
+          import { isNullish, isUndefined } from 'ts-data-forge';
+          declare const x: string | undefined;
+          const y = isNullish(x satisfies string | null | undefined);
+        `,
+        output: dedent`
+          import { isNullish, isUndefined } from 'ts-data-forge';
+          declare const x: string | undefined;
+          const y = isUndefined(x satisfies string | null | undefined);
+        `,
+        errors: [{ messageId: 'replaceTypeGuard' }],
+      },
+    ],
+  });
+});

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

@@ -3,7 +3,7 @@ import {
   type TSESLint,
   type TSESTree,
 } from '@typescript-eslint/utils';
-import { type DeepReadonly } from 'ts-type-forge';
+import { skipTypeWrappers } from './ast-utils.mjs';
 import {
   buildImportFixes,
   getNamedImports,
@@ -65,15 +65,15 @@ export const preferArrIsArray: TSESLint.RuleModule<MessageIds, Options> = {
                 return [];
               }
 
-              const replacement = `Arr.isArray${sourceCode.getText(node).slice(sourceCode.getText(callee).length)}`;
-
+              // Only the callee is replaced: parentheses the source put around
+              // it are outside its range, and stay balanced.
               // Add import only for the first node and only if not already imported
               const importFixes =
                 index === 0 && !hasArrImport
                   ? buildImportFixes(fixer, program, tsDataForgeImport, ['Arr'])
                   : [];
 
-              return [...importFixes, fixer.replaceText(node, replacement)];
+              return [...importFixes, fixer.replaceText(callee, 'Arr.isArray')];
             },
           });
         }
@@ -84,13 +84,18 @@ export const preferArrIsArray: TSESLint.RuleModule<MessageIds, Options> = {
 } as const;
 
 const isArrayIsArrayCall = (
-  node: DeepReadonly<TSESTree.CallExpression>,
+  // AST nodes hold mutable child arrays, so they are not deeply readonly.
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  node: TSESTree.CallExpression,
 ): boolean => {
   if (node.callee.type !== AST_NODE_TYPES.MemberExpression) {
     return false;
   }
 
-  const { object, property } = node.callee;
+  const { property } = node.callee;
+
+  // `(Array as ArrayConstructor).isArray` is still `Array.isArray`.
+  const object = skipTypeWrappers(node.callee.object);
 
   if (object.type !== AST_NODE_TYPES.Identifier) {
     return false;

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,
@@ -64,9 +69,7 @@ export const preferArrIsBoundedLengthArray: TSESLint.RuleModule<
           return;
         }
 
-        if (
-          sourceCode.getText(left.array) !== sourceCode.getText(right.array)
-        ) {
+        if (!isSameArrayText(left.array, right.array, sourceCode)) {
           return;
         }
 
@@ -77,25 +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;
         }
 
@@ -115,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,
@@ -58,13 +59,16 @@ export const preferArrIsFixedLengthArray: TSESLint.RuleModule<
 
         const isNegated = node.operator === '!==';
 
-        const isLengthOnLeft = isLengthAccess(node.left);
+        // Both sides are read through type wrappers.
+        const leftLength = asLengthAccess(node.left);
 
-        const lengthSide = node[isLengthOnLeft ? 'left' : 'right'];
+        const isLengthOnLeft = leftLength !== undefined;
+
+        const lengthSide = leftLength ?? asLengthAccess(node.right);
 
         const valueSide = node[isLengthOnLeft ? 'right' : 'left'];
 
-        if (!isLengthAccess(lengthSide)) {
+        if (lengthSide === undefined) {
           return;
         }
 
@@ -73,36 +77,19 @@ export const preferArrIsFixedLengthArray: 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),
           isNegated,
         });
       },
@@ -115,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);
 
@@ -148,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,
@@ -63,12 +66,15 @@ export const preferArrIsMaxLengthArray: 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 preferArrIsMaxLengthArray: 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 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);