eslint-plugin-ts-data-forge 0.10.4 → 0.10.6

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

@@ -202,25 +202,40 @@ describe('prefer-arr-generate', () => {
           const ys = xs.flatMap((x) => (x === undefined ? [] : [x]));
           const zs = xs.flatMap((x) => (skip ? [] : [x]));
         `,
-        output: dedent`
-          import { Arr } from 'ts-data-forge';
-          declare const xs: readonly (number | undefined)[];
-          declare const skip: boolean;
-          const ys = Arr.generate(function* () {
-            for (const x of xs) {
-              if (x !== undefined) {
-                yield x;
+        output: [
+          dedent`
+            import { Arr } from 'ts-data-forge';
+            declare const xs: readonly (number | undefined)[];
+            declare const skip: boolean;
+            const ys = Arr.generate(function* () {
+              for (const x of xs) {
+                if (x !== undefined) {
+                  yield x;
+                }
               }
-            }
-          });
-          const zs = Arr.generate(function* () {
-            for (const x of xs) {
-              if (!skip) {
-                yield x;
+            });
+            const zs = xs.flatMap((x) => (skip ? [] : [x]));
+          `,
+          dedent`
+            import { Arr } from 'ts-data-forge';
+            declare const xs: readonly (number | undefined)[];
+            declare const skip: boolean;
+            const ys = Arr.generate(function* () {
+              for (const x of xs) {
+                if (x !== undefined) {
+                  yield x;
+                }
               }
-            }
-          });
-        `,
+            });
+            const zs = Arr.generate(function* () {
+              for (const x of xs) {
+                if (!skip) {
+                  yield x;
+                }
+              }
+            });
+          `,
+        ],
         errors: [
           { messageId: 'useArrGenerate' },
           { messageId: 'useArrGenerate' },
@@ -237,40 +252,58 @@ describe('prefer-arr-generate', () => {
           const c = xs.flatMap((x) => (n < 0 ? [] : [x]));
           const d = xs.flatMap((x) => (!ok(x) ? [] : [x]));
         `,
-        output: dedent`
-          import { Arr } from 'ts-data-forge';
-          declare const xs: readonly (string | undefined)[];
-          declare const ok: (x: string | undefined) => boolean;
-          declare const n: number;
-          const a = Arr.generate(function* () {
-            for (const x of xs) {
-              if (x !== undefined && x !== '') {
-                yield x;
+        output: [
+          dedent`
+            import { Arr } from 'ts-data-forge';
+            declare const xs: readonly (string | undefined)[];
+            declare const ok: (x: string | undefined) => boolean;
+            declare const n: number;
+            const a = Arr.generate(function* () {
+              for (const x of xs) {
+                if (x !== undefined && x !== '') {
+                  yield x;
+                }
               }
-            }
-          });
-          const b = Arr.generate(function* () {
-            for (const x of xs) {
-              if (!ok(x)) {
-                yield x;
+            });
+            const b = xs.flatMap((x) => (ok(x) ? [] : [x]));
+            const c = xs.flatMap((x) => (n < 0 ? [] : [x]));
+            const d = xs.flatMap((x) => (!ok(x) ? [] : [x]));
+          `,
+          dedent`
+            import { Arr } from 'ts-data-forge';
+            declare const xs: readonly (string | undefined)[];
+            declare const ok: (x: string | undefined) => boolean;
+            declare const n: number;
+            const a = Arr.generate(function* () {
+              for (const x of xs) {
+                if (x !== undefined && x !== '') {
+                  yield x;
+                }
               }
-            }
-          });
-          const c = Arr.generate(function* () {
-            for (const x of xs) {
-              if (!(n < 0)) {
-                yield x;
+            });
+            const b = Arr.generate(function* () {
+              for (const x of xs) {
+                if (!ok(x)) {
+                  yield x;
+                }
               }
-            }
-          });
-          const d = Arr.generate(function* () {
-            for (const x of xs) {
-              if (ok(x)) {
-                yield x;
+            });
+            const c = Arr.generate(function* () {
+              for (const x of xs) {
+                if (!(n < 0)) {
+                  yield x;
+                }
               }
-            }
-          });
-        `,
+            });
+            const d = Arr.generate(function* () {
+              for (const x of xs) {
+                if (ok(x)) {
+                  yield x;
+                }
+              }
+            });
+          `,
+        ],
         errors: [
           { messageId: 'useArrGenerate' },
           { messageId: 'useArrGenerate' },
@@ -435,6 +468,25 @@ describe('prefer-arr-generate', () => {
         `,
         errors: [{ messageId: 'useArrGenerate' }],
       },
+      {
+        name: 'no fix when an import type binds Arr',
+        code: dedent`
+          import type { Arr } from 'ts-data-forge';
+          declare const xs: readonly number[];
+          const ys = xs.flatMap((x) => (x > 0 ? [x] : []));
+        `,
+        output: null,
+        errors: [{ messageId: 'useArrGenerate' }],
+      },
+      {
+        name: 'no fix where a local binding takes Arr',
+        code: dedent`
+          declare const xs: readonly number[];
+          export const f = (Arr: unknown) => xs.flatMap((x) => (x > 0 ? [x] : []));
+        `,
+        output: null,
+        errors: [{ messageId: 'useArrGenerate' }],
+      },
       {
         name: 'indents from the line the call starts on, and accepts a mutable array, a tuple or a type parameter',
         code: dedent`
@@ -446,34 +498,52 @@ describe('prefer-arr-generate', () => {
             const c = xs.flatMap((x) => (x > 0 ? [x] : []));
           };
         `,
-        output: dedent`
-          import { Arr } from 'ts-data-forge';
-          declare const ms: number[];
-          declare const ts: readonly [number, number];
-          export const f = <T extends readonly number[]>(xs: T): void => {
-            const a = Arr.generate(function* () {
-              for (const x of ms) {
-                if (x > 0) {
-                  yield x;
+        output: [
+          dedent`
+            import { Arr } from 'ts-data-forge';
+            declare const ms: number[];
+            declare const ts: readonly [number, number];
+            export const f = <T extends readonly number[]>(xs: T): void => {
+              const a = Arr.generate(function* () {
+                for (const x of ms) {
+                  if (x > 0) {
+                    yield x;
+                  }
                 }
-              }
-            });
-            const b = Arr.generate(function* () {
-              for (const x of ts) {
-                if (x > 0) {
-                  yield x;
+              });
+              const b = ts.flatMap((x) => (x > 0 ? [x] : []));
+              const c = xs.flatMap((x) => (x > 0 ? [x] : []));
+            };
+          `,
+          dedent`
+            import { Arr } from 'ts-data-forge';
+            declare const ms: number[];
+            declare const ts: readonly [number, number];
+            export const f = <T extends readonly number[]>(xs: T): void => {
+              const a = Arr.generate(function* () {
+                for (const x of ms) {
+                  if (x > 0) {
+                    yield x;
+                  }
                 }
-              }
-            });
-            const c = Arr.generate(function* () {
-              for (const x of xs) {
-                if (x > 0) {
-                  yield x;
+              });
+              const b = Arr.generate(function* () {
+                for (const x of ts) {
+                  if (x > 0) {
+                    yield x;
+                  }
                 }
-              }
-            });
-          };
-        `,
+              });
+              const c = Arr.generate(function* () {
+                for (const x of xs) {
+                  if (x > 0) {
+                    yield x;
+                  }
+                }
+              });
+            };
+          `,
+        ],
         errors: [
           { messageId: 'useArrGenerate' },
           { messageId: 'useArrGenerate' },
@@ -691,30 +761,50 @@ describe('prefer-arr-generate', () => {
             return [...a, ...b];
           };
         `,
-        output: dedent`
-          import { Arr } from 'ts-data-forge';
-          declare const c: readonly number[] | undefined;
-          export const f = (p: readonly number[] | undefined): readonly number[] => {
-            if (c === undefined || p === undefined) {
-              return [];
-            }
-            const a = Arr.generate(function* () {
-              for (const x of c) {
-                if (x > 0) {
-                  yield x;
-                }
+        output: [
+          dedent`
+            import { Arr } from 'ts-data-forge';
+            declare const c: readonly number[] | undefined;
+            export const f = (p: readonly number[] | undefined): readonly number[] => {
+              if (c === undefined || p === undefined) {
+                return [];
               }
-            });
-            const b = Arr.generate(function* () {
-              for (const x of p) {
-                if (x > 0) {
-                  yield x;
+              const a = Arr.generate(function* () {
+                for (const x of c) {
+                  if (x > 0) {
+                    yield x;
+                  }
                 }
+              });
+              const b = p.flatMap((x) => (x > 0 ? [x] : []));
+              return [...a, ...b];
+            };
+          `,
+          dedent`
+            import { Arr } from 'ts-data-forge';
+            declare const c: readonly number[] | undefined;
+            export const f = (p: readonly number[] | undefined): readonly number[] => {
+              if (c === undefined || p === undefined) {
+                return [];
               }
-            });
-            return [...a, ...b];
-          };
-        `,
+              const a = Arr.generate(function* () {
+                for (const x of c) {
+                  if (x > 0) {
+                    yield x;
+                  }
+                }
+              });
+              const b = Arr.generate(function* () {
+                for (const x of p) {
+                  if (x > 0) {
+                    yield x;
+                  }
+                }
+              });
+              return [...a, ...b];
+            };
+          `,
+        ],
         errors: [
           { messageId: 'useArrGenerate' },
           { messageId: 'useArrGenerate' },
@@ -737,34 +827,58 @@ describe('prefer-arr-generate', () => {
             return [...a, ...b];
           };
         `,
-        output: dedent`
-          import { Arr } from 'ts-data-forge';
-          declare const isNonEmpty: <T,>(
-            xs: readonly T[],
-          ) => xs is readonly [T, ...T[]];
-          declare const o: Readonly<{ names: readonly string[] }>;
-          declare const nested: readonly (readonly string[])[];
-          export const f = (): readonly string[] => {
-            if (!isNonEmpty(o.names)) {
-              return [];
-            }
-            const a = Arr.generate(function* () {
-              for (const x of o.names) {
-                if (x !== '') {
-                  yield x;
-                }
+        output: [
+          dedent`
+            import { Arr } from 'ts-data-forge';
+            declare const isNonEmpty: <T,>(
+              xs: readonly T[],
+            ) => xs is readonly [T, ...T[]];
+            declare const o: Readonly<{ names: readonly string[] }>;
+            declare const nested: readonly (readonly string[])[];
+            export const f = (): readonly string[] => {
+              if (!isNonEmpty(o.names)) {
+                return [];
               }
-            });
-            const b = Arr.generate(function* () {
-              for (const x of nested.flat()) {
-                if (x !== '') {
-                  yield x;
+              const a = Arr.generate(function* () {
+                for (const x of o.names) {
+                  if (x !== '') {
+                    yield x;
+                  }
                 }
+              });
+              const b = nested.flat().flatMap((x) => (x !== '' ? [x] : []));
+              return [...a, ...b];
+            };
+          `,
+          dedent`
+            import { Arr } from 'ts-data-forge';
+            declare const isNonEmpty: <T,>(
+              xs: readonly T[],
+            ) => xs is readonly [T, ...T[]];
+            declare const o: Readonly<{ names: readonly string[] }>;
+            declare const nested: readonly (readonly string[])[];
+            export const f = (): readonly string[] => {
+              if (!isNonEmpty(o.names)) {
+                return [];
               }
-            });
-            return [...a, ...b];
-          };
-        `,
+              const a = Arr.generate(function* () {
+                for (const x of o.names) {
+                  if (x !== '') {
+                    yield x;
+                  }
+                }
+              });
+              const b = Arr.generate(function* () {
+                for (const x of nested.flat()) {
+                  if (x !== '') {
+                    yield x;
+                  }
+                }
+              });
+              return [...a, ...b];
+            };
+          `,
+        ],
         errors: [
           { messageId: 'useArrGenerate' },
           { messageId: 'useArrGenerate' },
@@ -867,24 +981,38 @@ describe('prefer-arr-generate through type wrappers', () => {
           );
           const b = xs.flatMap!((x) => (x > 0 ? [x] : []));
         `,
-        output: dedent`
-          import { Arr } from 'ts-data-forge';
-          declare const xs: readonly number[];
-          const a = Arr.generate(function* () {
-            for (const x of xs satisfies readonly number[]) {
-              if (x > 0) {
-                yield x;
+        output: [
+          dedent`
+            import { Arr } from 'ts-data-forge';
+            declare const xs: readonly number[];
+            const a = Arr.generate(function* () {
+              for (const x of xs satisfies readonly number[]) {
+                if (x > 0) {
+                  yield x;
+                }
               }
-            }
-          });
-          const b = Arr.generate(function* () {
-            for (const x of xs) {
-              if (x > 0) {
-                yield x;
+            });
+            const b = xs.flatMap!((x) => (x > 0 ? [x] : []));
+          `,
+          dedent`
+            import { Arr } from 'ts-data-forge';
+            declare const xs: readonly number[];
+            const a = Arr.generate(function* () {
+              for (const x of xs satisfies readonly number[]) {
+                if (x > 0) {
+                  yield x;
+                }
               }
-            }
-          });
-        `,
+            });
+            const b = Arr.generate(function* () {
+              for (const x of xs) {
+                if (x > 0) {
+                  yield x;
+                }
+              }
+            });
+          `,
+        ],
         errors: [
           { messageId: 'useArrGenerate' },
           { messageId: 'useArrGenerate' },

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

@@ -72,11 +72,18 @@ ruleTester.run('prefer-arr-is-array', preferArrIsArray, {
         const result1 = Array.isArray(value1);
         const result2 = Array.isArray(value2);
       `,
-      output: dedent`
-        import { Arr } from 'ts-data-forge';
-        const result1 = Arr.isArray(value1);
-        const result2 = Arr.isArray(value2);
-      `,
+      output: [
+        dedent`
+          import { Arr } from 'ts-data-forge';
+          const result1 = Arr.isArray(value1);
+          const result2 = Array.isArray(value2);
+        `,
+        dedent`
+          import { Arr } from 'ts-data-forge';
+          const result1 = Arr.isArray(value1);
+          const result2 = Arr.isArray(value2);
+        `,
+      ],
       errors: [{ messageId: 'useIsArray' }, { messageId: 'useIsArray' }],
     },
   ],
@@ -157,3 +164,78 @@ describe('prefer-arr-is-array with parenthesized operands', () => {
     ],
   });
 });
+
+describe('prefer-arr-is-array brings Arr into scope', () => {
+  ruleTester.run('prefer-arr-is-array', preferArrIsArray, {
+    valid: [],
+    invalid: [
+      {
+        name: 'after a leading directive',
+        code: dedent`
+          'use client';
+          const result = Array.isArray(value);
+        `,
+        output: dedent`
+          'use client';
+          import { Arr } from 'ts-data-forge';
+          const result = Arr.isArray(value);
+        `,
+        errors: [{ messageId: 'useIsArray' }],
+      },
+      {
+        name: 'in the existing named import',
+        code: dedent`
+          import { Num } from 'ts-data-forge';
+          const result = Array.isArray(value);
+        `,
+        output: dedent`
+          import { Num, Arr } from 'ts-data-forge';
+          const result = Arr.isArray(value);
+        `,
+        errors: [{ messageId: 'useIsArray' }],
+      },
+      {
+        name: 'an inline type import becomes a value import',
+        code: dedent`
+          import { type 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: 'useIsArray' }],
+      },
+      {
+        name: 'no fix when a type-only declaration imports it',
+        code: dedent`
+          import type { Arr } from 'ts-data-forge';
+          const result = Array.isArray(value);
+        `,
+        output: null,
+        errors: [{ messageId: 'useIsArray' }],
+      },
+      {
+        name: 'the local name of an aliased import',
+        code: dedent`
+          import { Arr as A } from 'ts-data-forge';
+          const result = Array.isArray(value);
+        `,
+        output: dedent`
+          import { Arr as A } from 'ts-data-forge';
+          const result = A.isArray(value);
+        `,
+        errors: [{ messageId: 'useIsArray' }],
+      },
+      {
+        name: 'no fix when something else is named Arr where the call is',
+        code: dedent`
+          const Arr = 1;
+          const result = Array.isArray(value);
+        `,
+        output: null,
+        errors: [{ messageId: 'useIsArray' }],
+      },
+    ],
+  });
+});

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

@@ -1,16 +1,11 @@
 import type { TSESLint, TSESTree } from '@typescript-eslint/utils';
-import {
-  buildNamedImportFix,
-  getArgumentText,
-  getImportDeclarations,
-  getNamedImports,
-} from 'eslint-rule-forge';
+import { getArgumentText } from 'eslint-rule-forge';
 import {
   isArrayOrTupleExpression,
   isSameArrayText,
   parseLengthComparison,
 } from './ast-utils.mjs';
-import { TS_DATA_FORGE_MODULE } from './constants.mjs';
+import { tsDataForgeValueAt } from './import-binding.mjs';
 
 type Options = readonly [];
 
@@ -38,13 +33,6 @@ export const preferArrIsBoundedLengthArray: TSESLint.RuleModule<
   create: (context) => {
     const sourceCode = context.sourceCode;
 
-    const program = sourceCode.ast;
-
-    const tsDataForgeImports = getImportDeclarations(
-      program,
-      TS_DATA_FORGE_MODULE,
-    );
-
     const services = context.sourceCode.parserServices;
 
     const mut_nodesToFix: {
@@ -100,14 +88,14 @@ export const preferArrIsBoundedLengthArray: TSESLint.RuleModule<
         });
       },
       'Program:exit': () => {
-        const namedImports = getNamedImports(tsDataForgeImports);
+        const arrAt = tsDataForgeValueAt(sourceCode, 'Arr');
 
-        const hasArrImport = namedImports.includes('Arr');
-
-        for (const [
-          index,
-          { node, arrayExpression, minExpression, maxExpression },
-        ] of mut_nodesToFix.entries()) {
+        for (const {
+          node,
+          arrayExpression,
+          minExpression,
+          maxExpression,
+        } of mut_nodesToFix) {
           const arrayText = getArgumentText(sourceCode, arrayExpression);
 
           const minText = sourceCode.getText(minExpression);
@@ -116,6 +104,8 @@ export const preferArrIsBoundedLengthArray: TSESLint.RuleModule<
 
           const originalText = sourceCode.getText(node);
 
+          const arr = arrAt(node);
+
           context.report({
             node,
             messageId: 'useIsBoundedLengthArray',
@@ -125,18 +115,17 @@ export const preferArrIsBoundedLengthArray: TSESLint.RuleModule<
               min: minText,
               max: maxText,
             },
-            fix: (fixer) => {
-              const replacement = `Arr.isBoundedLengthArray(${minText}, ${maxText}, ${arrayText})`;
-
-              const importFixes =
-                index === 0 && !hasArrImport
-                  ? buildNamedImportFix(fixer, program, TS_DATA_FORGE_MODULE, [
-                      'Arr',
-                    ])
-                  : [];
-
-              return [...importFixes, fixer.replaceText(node, replacement)];
-            },
+            fix:
+              arr === undefined
+                ? null
+                : (fixer) => {
+                    const replacement = `${arr.localName}.isBoundedLengthArray(${minText}, ${maxText}, ${arrayText})`;
+
+                    return [
+                      ...arr.edits(fixer),
+                      fixer.replaceText(node, replacement),
+                    ];
+                  },
           });
         }
       },