eslint-plugin-ts-data-forge 0.8.6 → 0.10.0

package/src/rules/prefer-pipe-map-nullable.test.mts

@@ -0,0 +1,470 @@
+import parser from '@typescript-eslint/parser';
+import { RuleTester } from '@typescript-eslint/rule-tester';
+import dedent from 'dedent';
+import { preferPipeMapNullable } from './prefer-pipe-map-nullable.mjs';
+
+const tester = new RuleTester({
+  languageOptions: {
+    parser,
+    parserOptions: {
+      ecmaVersion: 2020,
+      sourceType: 'module',
+      projectService: {
+        allowDefaultProject: ['*.ts*'],
+      },
+      tsconfigRootDir: `${import.meta.dirname}/../..`,
+    },
+  },
+});
+
+/** The same rule with no type information. */
+const untypedTester = new RuleTester({
+  languageOptions: {
+    parser,
+    parserOptions: {
+      ecmaVersion: 2020,
+      sourceType: 'module',
+    },
+  },
+});
+
+describe('prefer-pipe-map-nullable', () => {
+  tester.run('prefer-pipe-map-nullable', preferPipeMapNullable, {
+    valid: [
+      {
+        name: 'ignores pipe(x).mapNullable(fn)',
+        code: dedent`
+          import { pipe } from 'ts-data-forge';
+          declare const x: number | undefined;
+          const y = pipe(x).mapNullable((v) => v + 1).value;
+        `,
+      },
+      {
+        name: 'ignores map with another function',
+        code: dedent`
+          import { pipe } from 'ts-data-forge';
+          declare const x: number | undefined;
+          declare const f: (v: number | undefined) => number;
+          const y = pipe(x).map(f).value;
+        `,
+      },
+      {
+        name: 'ignores the two-argument mapNullable(value, fn)',
+        code: dedent`
+          import { mapNullable, pipe } from 'ts-data-forge';
+          declare const x: number | undefined;
+          declare const g: (v: number | undefined) => (w: number) => number;
+          const y = pipe(x).map((v) => mapNullable(v, (w) => w + 1)).value;
+          const z = pipe(x).map(g(mapNullable(x, (w) => w + 1))).value;
+        `,
+      },
+      {
+        name: 'ignores mapNullable with explicit type arguments',
+        code: dedent`
+          import { mapNullable, pipe } from 'ts-data-forge';
+          declare const x: number | undefined;
+          const y = pipe(x).map(mapNullable<number, number>((v) => v + 1)).value;
+        `,
+      },
+      {
+        name: 'ignores map with explicit type arguments',
+        code: dedent`
+          import { mapNullable, pipe } from 'ts-data-forge';
+          declare const x: number | undefined;
+          const y = pipe(x).map<number | undefined>(mapNullable((v: number) => v + 1)).value;
+        `,
+      },
+      {
+        name: 'ignores a mapNullable not imported from ts-data-forge',
+        code: dedent`
+          import { pipe } from 'ts-data-forge';
+          const mapNullable =
+            <A, B>(fn: (a: A) => B) =>
+            (a: A | null | undefined): B | undefined =>
+              a == null ? undefined : fn(a);
+          declare const x: number | undefined;
+          const y = pipe(x).map(mapNullable((v: number) => v + 1)).value;
+        `,
+      },
+      {
+        name: 'ignores a mapNullable that shadows the import',
+        code: dedent`
+          import { mapNullable as _m, pipe } from 'ts-data-forge';
+          import { mapNullable } from 'ts-data-forge';
+          declare const x: number | undefined;
+          const run = (mapNullable: (fn: (v: number) => number) => (v: number | undefined) => number) =>
+            pipe(x).map(mapNullable((v) => v + 1)).value;
+        `,
+      },
+      {
+        name: 'ignores a map on something that is not a pipe',
+        code: dedent`
+          import { mapNullable } from 'ts-data-forge';
+          declare const xs: readonly (number | undefined)[];
+          const ys = xs.map(mapNullable((v) => v + 1));
+        `,
+      },
+      {
+        name: 'ignores a pipe not imported from ts-data-forge',
+        code: dedent`
+          import { mapNullable } from 'ts-data-forge';
+          import { pipe } from 'some-other-pipe';
+          declare const x: number | undefined;
+          const y = pipe(x).map(mapNullable((v: number) => v + 1));
+        `,
+      },
+      {
+        name: 'ignores a pipe held in a variable',
+        code: dedent`
+          import { mapNullable, pipe } from 'ts-data-forge';
+          declare const x: number | undefined;
+          const p = pipe(x);
+          const y = p.map(mapNullable((v) => v + 1)).value;
+        `,
+      },
+      {
+        name: 'ignores optional calls',
+        code: dedent`
+          import { mapNullable, pipe } from 'ts-data-forge';
+          declare const x: number | undefined;
+          const y = pipe(x).map?.(mapNullable((v) => v + 1));
+        `,
+      },
+      {
+        name: 'ignores a spread argument',
+        code: dedent`
+          import { mapNullable, pipe } from 'ts-data-forge';
+          declare const x: number | undefined;
+          declare const args: readonly [(v: number) => number];
+          const y = pipe(x).map(mapNullable(...args));
+        `,
+      },
+    ],
+    invalid: [
+      {
+        name: 'fixes an inline function whose result type is not a literal',
+        code: dedent`
+          import { mapNullable, pipe } from 'ts-data-forge';
+          declare const x: number | undefined;
+          const y = pipe(x).map(mapNullable((v) => v + 1)).value;
+        `,
+        output: dedent`
+          import { mapNullable, pipe } from 'ts-data-forge';
+          declare const x: number | undefined;
+          const y = pipe(x).mapNullable((v) => v + 1).value;
+        `,
+        errors: [{ messageId: 'useMapNullable' }],
+      },
+      {
+        name: 'fixes a function reference',
+        code: dedent`
+          import { mapNullable, pipe } from 'ts-data-forge';
+          declare const x: string | undefined;
+          declare const f: (s: string) => 'a';
+          const y = pipe(x).map(mapNullable(f)).value;
+        `,
+        output: dedent`
+          import { mapNullable, pipe } from 'ts-data-forge';
+          declare const x: string | undefined;
+          declare const f: (s: string) => 'a';
+          const y = pipe(x).mapNullable(f).value;
+        `,
+        errors: [{ messageId: 'useMapNullable' }],
+      },
+      {
+        name: 'fixes an inline function with a return type annotation',
+        code: dedent`
+          import { mapNullable, pipe } from 'ts-data-forge';
+          declare const x: number | undefined;
+          const y = pipe(x).map(mapNullable((v): 'a' => 'a')).value;
+        `,
+        output: dedent`
+          import { mapNullable, pipe } from 'ts-data-forge';
+          declare const x: number | undefined;
+          const y = pipe(x).mapNullable((v): 'a' => 'a').value;
+        `,
+        errors: [{ messageId: 'useMapNullable' }],
+      },
+      {
+        name: 'fixes an inline function returning an object of non-literals',
+        code: dedent`
+          import { mapNullable, pipe } from 'ts-data-forge';
+          declare const x: number | undefined;
+          const y = pipe(x).map(mapNullable((v) => ({ v, ok: v > 0 }))).value;
+        `,
+        output: dedent`
+          import { mapNullable, pipe } from 'ts-data-forge';
+          declare const x: number | undefined;
+          const y = pipe(x).mapNullable((v) => ({ v, ok: v > 0 })).value;
+        `,
+        errors: [{ messageId: 'useMapNullable' }],
+      },
+      {
+        name: 'fixes every link of a chain',
+        code: dedent`
+          import { mapNullable, pipe } from 'ts-data-forge';
+          declare const x: string | undefined;
+          const y = pipe(x)
+            .map(mapNullable((s) => s.length))
+            .map((n) => n)
+            .map(mapNullable((n) => n * 2)).value;
+        `,
+        output: dedent`
+          import { mapNullable, pipe } from 'ts-data-forge';
+          declare const x: string | undefined;
+          const y = pipe(x)
+            .mapNullable((s) => s.length)
+            .map((n) => n)
+            .mapNullable((n) => n * 2).value;
+        `,
+        errors: [
+          { messageId: 'useMapNullable' },
+          { messageId: 'useMapNullable' },
+        ],
+      },
+      {
+        name: 'fixes after mapOptional and mapNullable links',
+        code: dedent`
+          import { mapNullable, Optional, pipe } from 'ts-data-forge';
+          declare const o: Optional<number>;
+          const y = pipe(o)
+            .mapOptional((n) => n + 1)
+            .map((p) => Optional.unwrapOr(p, undefined))
+            .mapNullable((n) => n)
+            .map(mapNullable((n) => n * 2)).value;
+        `,
+        output: dedent`
+          import { mapNullable, Optional, pipe } from 'ts-data-forge';
+          declare const o: Optional<number>;
+          const y = pipe(o)
+            .mapOptional((n) => n + 1)
+            .map((p) => Optional.unwrapOr(p, undefined))
+            .mapNullable((n) => n)
+            .mapNullable((n) => n * 2).value;
+        `,
+        errors: [{ messageId: 'useMapNullable' }],
+      },
+      {
+        name: 'fixes aliased and namespace imports',
+        code: dedent`
+          import * as tdf from 'ts-data-forge';
+          import { mapNullable as mapN } from 'ts-data-forge';
+          declare const x: number | undefined;
+          const y = tdf.pipe(x).map(tdf.mapNullable((v) => v + 1)).value;
+          const z = tdf.pipe(x).map(mapN((v) => v + 1)).value;
+        `,
+        output: dedent`
+          import * as tdf from 'ts-data-forge';
+          import { mapNullable as mapN } from 'ts-data-forge';
+          declare const x: number | undefined;
+          const y = tdf.pipe(x).mapNullable((v) => v + 1).value;
+          const z = tdf.pipe(x).mapNullable((v) => v + 1).value;
+        `,
+        errors: [
+          { messageId: 'useMapNullable' },
+          { messageId: 'useMapNullable' },
+        ],
+      },
+      {
+        name: 'fixes a pipe imported from ts-std-forge',
+        code: dedent`
+          import { mapNullable } from 'ts-data-forge';
+          import { pipe } from 'ts-std-forge';
+          declare const x: number | undefined;
+          const y = pipe(x).map(mapNullable((v) => v + 1)).value;
+        `,
+        output: dedent`
+          import { mapNullable } from 'ts-data-forge';
+          import { pipe } from 'ts-std-forge';
+          declare const x: number | undefined;
+          const y = pipe(x).mapNullable((v) => v + 1).value;
+        `,
+        errors: [{ messageId: 'useMapNullable' }],
+      },
+      {
+        name: 'keeps comments around the function and a sequence argument',
+        code: dedent`
+          import { mapNullable, pipe } from 'ts-data-forge';
+          declare const x: number | undefined;
+          declare const f: (v: number) => number;
+          const y = pipe(x).map(/* a */ mapNullable((0, f)) /* b */).value;
+        `,
+        output: dedent`
+          import { mapNullable, pipe } from 'ts-data-forge';
+          declare const x: number | undefined;
+          declare const f: (v: number) => number;
+          const y = pipe(x).mapNullable(/* a */ (0, f) /* b */).value;
+        `,
+        errors: [{ messageId: 'useMapNullable' }],
+      },
+      {
+        name: 'suggests when the inferred result is a literal',
+        code: dedent`
+          import { mapNullable, pipe } from 'ts-data-forge';
+          declare const x: number | undefined;
+          const y = pipe(x).map(mapNullable((v) => 'a')).value;
+        `,
+        errors: [
+          {
+            messageId: 'useMapNullable',
+            suggestions: [
+              {
+                messageId: 'suggestMapNullable',
+                output: dedent`
+                  import { mapNullable, pipe } from 'ts-data-forge';
+                  declare const x: number | undefined;
+                  const y = pipe(x).mapNullable((v) => 'a').value;
+                `,
+              },
+            ],
+          },
+        ],
+      },
+      {
+        name: 'suggests when the inferred result is a tuple',
+        code: dedent`
+          import { mapNullable, pipe } from 'ts-data-forge';
+          declare const x: number | undefined;
+          const y = pipe(x).map(mapNullable((v) => [v, 1])).value;
+        `,
+        errors: [
+          {
+            messageId: 'useMapNullable',
+            suggestions: [
+              {
+                messageId: 'suggestMapNullable',
+                output: dedent`
+                  import { mapNullable, pipe } from 'ts-data-forge';
+                  declare const x: number | undefined;
+                  const y = pipe(x).mapNullable((v) => [v, 1]).value;
+                `,
+              },
+            ],
+          },
+        ],
+      },
+      {
+        name: 'suggests when a literal is nested in an object',
+        code: dedent`
+          import { mapNullable, pipe } from 'ts-data-forge';
+          declare const x: number | undefined;
+          const y = pipe(x).map(mapNullable((v) => ({ kind: 'n', v }))).value;
+        `,
+        errors: [
+          {
+            messageId: 'useMapNullable',
+            suggestions: [
+              {
+                messageId: 'suggestMapNullable',
+                output: dedent`
+                  import { mapNullable, pipe } from 'ts-data-forge';
+                  declare const x: number | undefined;
+                  const y = pipe(x).mapNullable((v) => ({ kind: 'n', v })).value;
+                `,
+              },
+            ],
+          },
+        ],
+      },
+      {
+        name: 'suggests when a comment inside mapNullable(…) would be dropped',
+        code: dedent`
+          import { mapNullable, pipe } from 'ts-data-forge';
+          declare const x: number | undefined;
+          declare const f: (v: number) => number;
+          const y = pipe(x).map(mapNullable(/* keep */ f)).value;
+        `,
+        errors: [
+          {
+            messageId: 'useMapNullable',
+            suggestions: [
+              {
+                messageId: 'suggestMapNullable',
+                output: dedent`
+                  import { mapNullable, pipe } from 'ts-data-forge';
+                  declare const x: number | undefined;
+                  declare const f: (v: number) => number;
+                  const y = pipe(x).mapNullable(f).value;
+                `,
+              },
+            ],
+          },
+        ],
+      },
+      {
+        name: 'suggests when a type wrapper around mapNullable would be dropped',
+        code: dedent`
+          import { mapNullable, pipe } from 'ts-data-forge';
+          declare const x: number | undefined;
+          declare const f: (v: number) => number;
+          const y = pipe(x).map((mapNullable as typeof mapNullable)(f)).value;
+        `,
+        errors: [
+          {
+            messageId: 'useMapNullable',
+            suggestions: [
+              {
+                messageId: 'suggestMapNullable',
+                output: dedent`
+                  import { mapNullable, pipe } from 'ts-data-forge';
+                  declare const x: number | undefined;
+                  declare const f: (v: number) => number;
+                  const y = pipe(x).mapNullable(f).value;
+                `,
+              },
+            ],
+          },
+        ],
+      },
+    ],
+  });
+
+  untypedTester.run(
+    'prefer-pipe-map-nullable (no type information)',
+    preferPipeMapNullable,
+    {
+      valid: [],
+      invalid: [
+        {
+          name: 'fixes a function reference',
+          code: dedent`
+            import { mapNullable, pipe } from 'ts-data-forge';
+            declare const x: number | undefined;
+            declare const f: (v: number) => number;
+            const y = pipe(x).map(mapNullable(f)).value;
+          `,
+          output: dedent`
+            import { mapNullable, pipe } from 'ts-data-forge';
+            declare const x: number | undefined;
+            declare const f: (v: number) => number;
+            const y = pipe(x).mapNullable(f).value;
+          `,
+          errors: [{ messageId: 'useMapNullable' }],
+        },
+        {
+          name: 'suggests for an inline function it cannot type',
+          code: dedent`
+            import { mapNullable, pipe } from 'ts-data-forge';
+            declare const x: number | undefined;
+            const y = pipe(x).map(mapNullable((v) => v + 1)).value;
+          `,
+          errors: [
+            {
+              messageId: 'useMapNullable',
+              suggestions: [
+                {
+                  messageId: 'suggestMapNullable',
+                  output: dedent`
+                    import { mapNullable, pipe } from 'ts-data-forge';
+                    declare const x: number | undefined;
+                    const y = pipe(x).mapNullable((v) => v + 1).value;
+                  `,
+                },
+              ],
+            },
+          ],
+        },
+      ],
+    },
+  );
+});

package/src/rules/prefer-range-for-loop.mts

@@ -1,5 +1,6 @@
 import {
   AST_NODE_TYPES,
+  ASTUtils,
   type TSESLint,
   type TSESTree,
 } from '@typescript-eslint/utils';
@@ -42,12 +43,47 @@ export const preferRangeForLoop: TSESLint.RuleModule<MessageIds, Options> = {
       TS_DATA_FORGE_MODULE,
     );
 
+    /**
+     * Whether `node` is the same value on every iteration: a literal, or a
+     * variable that is never reassigned anywhere (not only in the loop, since
+     * a function the loop calls could reassign it). The loop reads its end and
+     * its step on every iteration, and `range` reads them once.
+     */
+    const isStableBound = (
+      // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+      wrapped: TSESTree.Node,
+    ): boolean => {
+      const node = skipTypeWrappers(wrapped);
+
+      if (node.type === AST_NODE_TYPES.Literal) {
+        return true;
+      }
+
+      if (node.type !== AST_NODE_TYPES.Identifier) {
+        return false;
+      }
+
+      const variable = ASTUtils.findVariable(
+        sourceCode.getScope(node),
+        node.name,
+      );
+
+      return (
+        variable !== null &&
+        variable.defs.length > 0 &&
+        variable.references.every(
+          (reference) => !reference.isWrite() || reference.init === true,
+        )
+      );
+    };
+
     const mut_nodesToFix: {
       node: TSESTree.ForStatement;
       varName: string;
       begin: string;
       end: string;
       step?: string;
+      fixable: boolean;
     }[] = [];
 
     return {
@@ -74,6 +110,11 @@ export const preferRangeForLoop: TSESLint.RuleModule<MessageIds, Options> = {
 
         const beginExpr = declaration.init;
 
+        // `range` takes safe integers only.
+        if (isNonIntegerNumberLiteral(beginExpr)) {
+          return;
+        }
+
         // Check test: i < end. The loop variable and the step are read
         // through type wrappers: `(i satisfies number) < n` tests `i`, and
         // `i += 0 as number` still steps by 0.
@@ -126,19 +167,35 @@ export const preferRangeForLoop: TSESLint.RuleModule<MessageIds, Options> = {
             const stepNum = stepValue.value;
 
             // Only support positive integer steps
-            if (typeof stepNum === 'number' && stepNum > 0) {
+            if (
+              typeof stepNum === 'number' &&
+              Number.isSafeInteger(stepNum) &&
+              stepNum > 0
+            ) {
               mut_step = stepNum === 1 ? undefined : stepNum.toString();
             } else {
               return;
             }
+          } else if (isNegatedLiteral(stepValue)) {
+            // `i += -1` under `i < end` never gets there, and `range` with a
+            // negative step yields nothing: no fix that type-checks would
+            // keep that.
+            return;
           } else {
-            // Variable step like i += step
+            // Variable step like i += step. Its type is left to the type
+            // checker: a step that is not a non-zero safe integer makes the
+            // fixed `range(...)` call fail to type-check.
             mut_step = getArgumentText(sourceCode, node.update.right);
           }
         } else {
           return;
         }
 
+        // `const i` would not take an assignment anywhere but the update.
+        if (isAssignedOutsideUpdate(sourceCode, declaration, node.update)) {
+          return;
+        }
+
         const beginText = getArgumentText(sourceCode, beginExpr);
 
         const endText = getArgumentText(sourceCode, endExpr);
@@ -149,6 +206,10 @@ export const preferRangeForLoop: TSESLint.RuleModule<MessageIds, Options> = {
           begin: beginText,
           end: endText,
           step: mut_step,
+          fixable:
+            isStableBound(endExpr) &&
+            (node.update.type !== AST_NODE_TYPES.AssignmentExpression ||
+              isStableBound(node.update.right)),
         });
       },
       'Program:exit': () => {
@@ -156,10 +217,11 @@ export const preferRangeForLoop: TSESLint.RuleModule<MessageIds, Options> = {
 
         const hasRangeImport = namedImports.includes('range');
 
-        for (const [
-          index,
-          { node, varName, begin, end, step },
-        ] of mut_nodesToFix.entries()) {
+        const importCarrier = mut_nodesToFix.find(({ fixable }) => fixable);
+
+        for (const entry of mut_nodesToFix) {
+          const { node, varName, begin, end, step } = entry;
+
           context.report({
             node: node.init ?? node,
             messageId: 'useRangeForLoop',
@@ -168,25 +230,33 @@ export const preferRangeForLoop: TSESLint.RuleModule<MessageIds, Options> = {
               begin,
               end,
             },
-            fix: (fixer) => {
-              const bodyText = sourceCode.getText(node.body);
+            fix: entry.fixable
+              ? (fixer) => {
+                  const bodyText = sourceCode.getText(node.body);
 
-              const rangeArgs =
-                step === undefined
-                  ? `${begin}, ${end}`
-                  : `${begin}, ${end}, ${step}`;
+                  const rangeArgs =
+                    step === undefined
+                      ? `${begin}, ${end}`
+                      : `${begin}, ${end}, ${step}`;
 
-              const replacement = `for (const ${varName} of range(${rangeArgs})) ${bodyText}`;
+                  const replacement = `for (const ${varName} of range(${rangeArgs})) ${bodyText}`;
 
-              const importFixes =
-                index === 0 && !hasRangeImport
-                  ? buildNamedImportFix(fixer, program, TS_DATA_FORGE_MODULE, [
-                      'range',
-                    ])
-                  : [];
+                  // The import fix lives on the first fixable report:
+                  // `insertTextBefore(program, …)` produces overlapping ranges
+                  // otherwise.
+                  const importFixes =
+                    entry === importCarrier && !hasRangeImport
+                      ? buildNamedImportFix(
+                          fixer,
+                          program,
+                          TS_DATA_FORGE_MODULE,
+                          ['range'],
+                        )
+                      : [];
 
-              return [...importFixes, fixer.replaceText(node, replacement)];
-            },
+                  return [...importFixes, fixer.replaceText(node, replacement)];
+                }
+              : undefined,
           });
         }
       },
@@ -194,3 +264,54 @@ export const preferRangeForLoop: TSESLint.RuleModule<MessageIds, Options> = {
   },
   defaultOptions: [],
 } as const;
+
+const isNegatedLiteral = (
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  node: TSESTree.Node,
+): boolean =>
+  node.type === AST_NODE_TYPES.UnaryExpression &&
+  node.operator === '-' &&
+  skipTypeWrappers(node.argument).type === AST_NODE_TYPES.Literal;
+
+const isNonIntegerNumberLiteral = (
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  wrapped: TSESTree.Node,
+): boolean => {
+  const node = skipTypeWrappers(wrapped);
+
+  return (
+    node.type === AST_NODE_TYPES.Literal &&
+    typeof node.value === 'number' &&
+    !Number.isSafeInteger(node.value)
+  );
+};
+
+/**
+ * Whether the loop variable declared by `declaration` is written anywhere but
+ * its initializer and the loop's `update`.
+ */
+const isAssignedOutsideUpdate = (
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  sourceCode: TSESLint.SourceCode,
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  declaration: TSESTree.VariableDeclarator,
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  update: TSESTree.Expression,
+): boolean =>
+  sourceCode
+    .getDeclaredVariables(declaration)
+    .flatMap((variable) => variable.references)
+    .some(
+      (reference) =>
+        reference.isWrite() &&
+        reference.init !== true &&
+        !isWithin(reference.identifier, update),
+    );
+
+const isWithin = (
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  node: TSESTree.Node,
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  container: TSESTree.Node,
+): boolean =>
+  container.range[0] <= node.range[0] && node.range[1] <= container.range[1];