eslint-plugin-ts-data-forge 0.10.5 → 0.10.7

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,39 +827,292 @@ 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 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 [];
               }
-            });
-            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 = Arr.generate(function* () {
+                for (const x of nested.flat()) {
+                  if (x !== '') {
+                    yield x;
+                  }
+                }
+              });
+              return [...a, ...b];
+            };
+          `,
+        ],
+        errors: [
+          { messageId: 'useArrGenerate' },
+          { messageId: 'useArrGenerate' },
+        ],
+      },
+      {
+        name: 'only suggests when a comment between the receiver and `.flatMap` would be lost',
+        code: dedent`
+          declare const xs: readonly number[];
+          const ys = xs
+            // keep only the positives
+            .flatMap((x) => (x > 0 ? [x] : []));
+        `,
+        output: null,
+        errors: [
+          {
+            messageId: 'useArrGenerate',
+            suggestions: [
+              {
+                messageId: 'suggestArrGenerate',
+                output: dedent`
+                  import { Arr } from 'ts-data-forge';
+                  declare const xs: readonly number[];
+                  const ys = Arr.generate(function* () {
+                    for (const x of xs) {
+                      if (x > 0) {
+                        yield x;
+                      }
+                    }
+                  });
+                `,
+              },
+            ],
+          },
+        ],
+      },
+      {
+        name: 'only suggests when a comment after `flatMap(` would be lost',
+        code: dedent`
+          declare const xs: readonly number[];
+          const ys = xs.flatMap(
+            // keep only the positives
+            (x) => (x > 0 ? [x] : []),
+          );
+        `,
+        output: null,
+        errors: [
+          {
+            messageId: 'useArrGenerate',
+            suggestions: [
+              {
+                messageId: 'suggestArrGenerate',
+                output: dedent`
+                  import { Arr } from 'ts-data-forge';
+                  declare const xs: readonly number[];
+                  const ys = Arr.generate(function* () {
+                    for (const x of xs) {
+                      if (x > 0) {
+                        yield x;
+                      }
+                    }
+                  });
+                `,
+              },
+            ],
+          },
+        ],
+      },
+      {
+        name: 'only suggests when a comment after the callback, before `)` would be lost',
+        code: dedent`
+          declare const xs: readonly number[];
+          const ys = xs.flatMap(
+            (x) => (x > 0 ? [x] : []),
+            // keep only the positives
+          );
+        `,
+        output: null,
+        errors: [
+          {
+            messageId: 'useArrGenerate',
+            suggestions: [
+              {
+                messageId: 'suggestArrGenerate',
+                output: dedent`
+                  import { Arr } from 'ts-data-forge';
+                  declare const xs: readonly number[];
+                  const ys = Arr.generate(function* () {
+                    for (const x of xs) {
+                      if (x > 0) {
+                        yield x;
+                      }
+                    }
+                  });
+                `,
+              },
+            ],
+          },
+        ],
+      },
+      {
+        name: 'keeps the fix automatic when the comment is inside the carried type argument',
+        code: dedent`
+          declare const xs: readonly number[];
+          const ys = xs.flatMap</* positives */ number>((x) => (x > 0 ? [x] : []));
+        `,
+        output: dedent`
+          import { Arr } from 'ts-data-forge';
+          declare const xs: readonly number[];
+          const ys = Arr.generate</* positives */ number>(function* () {
+            for (const x of xs) {
+              if (x > 0) {
+                yield x;
               }
+            }
+          });
+        `,
+        errors: [{ messageId: 'useArrGenerate' }],
+      },
+      {
+        name: 'keeps the fix automatic when the comment is inside the receiver or the parameter',
+        code: dedent`
+          declare const f: (a: readonly { a: number }[]) => readonly { a: number }[];
+          declare const xs: readonly { a: number }[];
+          const ys = f(/* all */ xs).flatMap(({ a /* the value */ }) => (a > 0 ? [a] : []));
+        `,
+        output: dedent`
+          import { Arr } from 'ts-data-forge';
+          declare const f: (a: readonly { a: number }[]) => readonly { a: number }[];
+          declare const xs: readonly { a: number }[];
+          const ys = Arr.generate(function* () {
+            for (const { a /* the value */ } of f(/* all */ xs)) {
+              if (a > 0) {
+                yield a;
+              }
+            }
+          });
+        `,
+        errors: [{ messageId: 'useArrGenerate' }],
+      },
+      {
+        name: 'only suggests when a comment in a negated test would be lost',
+        code: dedent`
+          declare const xs: readonly number[];
+          const ys = xs.flatMap((x) => (x > 0 && /* small */ x < 9 ? [] : [x]));
+        `,
+        output: null,
+        errors: [
+          {
+            messageId: 'useArrGenerate',
+            suggestions: [
+              {
+                messageId: 'suggestArrGenerate',
+                output: dedent`
+                  import { Arr } from 'ts-data-forge';
+                  declare const xs: readonly number[];
+                  const ys = Arr.generate(function* () {
+                    for (const x of xs) {
+                      if (!(x > 0) || !(x < 9)) {
+                        yield x;
+                      }
+                    }
+                  });
+                `,
+              },
+            ],
+          },
+        ],
+      },
+      {
+        name: 'only suggests when a comment before `.flatMap` would be lost, even if a kept comment starts with the same text',
+        code: dedent`
+          declare const xs: readonly number[];
+          const ys = xs // TODO
+            .flatMap((x) => {
+              // TODO: check this
+              const y = x + 1;
+              return y > 0 ? [y] : [];
             });
-            return [...a, ...b];
-          };
         `,
+        output: null,
         errors: [
-          { messageId: 'useArrGenerate' },
-          { messageId: 'useArrGenerate' },
+          {
+            messageId: 'useArrGenerate',
+            suggestions: [
+              {
+                messageId: 'suggestArrGenerate',
+                output: dedent`
+                  import { Arr } from 'ts-data-forge';
+                  declare const xs: readonly number[];
+                  const ys = Arr.generate(function* () {
+                    for (const x of xs) {
+                      // TODO: check this
+                      const y = x + 1;
+                      if (y > 0) {
+                        yield y;
+                      }
+                    }
+                  });
+                `,
+              },
+            ],
+          },
         ],
       },
+      {
+        name: 'keeps the fix automatic for a multi-line comment in the prelude',
+        code: dedent`
+          declare const xs: readonly number[];
+          const ys = xs.flatMap((x) => {
+            /*
+             * Odd ones only.
+             */
+            const y = x;
+            return y % 2 === 1 ? [y] : [];
+          });
+        `,
+        output: dedent`
+          import { Arr } from 'ts-data-forge';
+          declare const xs: readonly number[];
+          const ys = Arr.generate(function* () {
+            for (const x of xs) {
+              /*
+               * Odd ones only.
+               */
+              const y = x;
+              if (y % 2 === 1) {
+                yield y;
+              }
+            }
+          });
+        `,
+        errors: [{ messageId: 'useArrGenerate' }],
+      },
       {
         name: 'only suggests when a comment would be lost',
         code: dedent`
@@ -867,24 +1210,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' },