eslint-plugin-ts-data-forge 0.1.0

package/src/rules/prefer-num-safe-parse-int.mts

@@ -0,0 +1,166 @@
+import {
+  AST_NODE_TYPES,
+  type TSESLint,
+  type TSESTree,
+} from '@typescript-eslint/utils';
+import * as ts from 'typescript';
+import {
+  buildImportFixes,
+  getNamedImports,
+  getTsDataForgeImport,
+} from './import-utils.mjs';
+
+type Options = readonly [];
+
+type MessageIds = 'useSafeParseInt';
+
+/**
+ * Returns `true` when every constituent of `type` is string-like, i.e. the type
+ * is assignable to the `string` parameter of `Num.safeParseInt`. A union such
+ * as `string | undefined` is rejected so the autofix never produces a type
+ * error.
+ */
+// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+const isStringType = (type: ts.Type): boolean => {
+  const parts = type.isUnion() ? type.types : ([type] as const);
+
+  return (
+    parts.length > 0 &&
+    parts.every((t) => (t.flags & ts.TypeFlags.StringLike) !== 0)
+  );
+};
+
+/**
+ * Detects the base-10 forms of `parseInt` / `Number.parseInt` (`parseInt(x)` or
+ * `parseInt(x, 10)`) and replaces them with
+ * `Result.unwrapOkOr(Num.safeParseInt(x), Number.NaN)` (ts-data-forge).
+ *
+ * Other radixes (e.g. `parseInt(x, 16)`) are intentionally left untouched, as
+ * `Num.safeParseInt` only supports base 10.
+ */
+export const preferNumSafeParseInt: TSESLint.RuleModule<MessageIds, Options> = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description:
+        'Replace `parseInt(x, 10)` with `Result.unwrapOkOr(Num.safeParseInt(x), Number.NaN)` from ts-data-forge.',
+    },
+    fixable: 'code',
+    schema: [],
+    messages: {
+      useSafeParseInt:
+        'Replace `{{original}}` with `Result.unwrapOkOr(Num.safeParseInt({{argName}}), Number.NaN)` from ts-data-forge.',
+    },
+  },
+
+  create: (context) => {
+    const sourceCode = context.sourceCode;
+
+    const program = sourceCode.ast;
+
+    const tsDataForgeImport = getTsDataForgeImport(program);
+
+    const services = context.sourceCode.parserServices;
+
+    const mut_nodesToFix: {
+      node: TSESTree.CallExpression;
+      argExpression: TSESTree.Expression;
+    }[] = [];
+
+    return {
+      CallExpression: (node) => {
+        const { callee } = node;
+
+        // Match `parseInt(...)` or `Number.parseInt(...)`.
+        const isGlobalParseInt =
+          callee.type === AST_NODE_TYPES.Identifier &&
+          callee.name === 'parseInt';
+
+        const isNumberParseInt =
+          callee.type === AST_NODE_TYPES.MemberExpression &&
+          !callee.computed &&
+          callee.object.type === AST_NODE_TYPES.Identifier &&
+          callee.object.name === 'Number' &&
+          callee.property.type === AST_NODE_TYPES.Identifier &&
+          callee.property.name === 'parseInt';
+
+        if (!isGlobalParseInt && !isNumberParseInt) return;
+
+        const args = node.arguments;
+
+        const firstArg = args[0];
+
+        if (firstArg === undefined) return;
+
+        // Spread argument (`parseInt(...rest)`) cannot be rewritten safely.
+        if (firstArg.type === AST_NODE_TYPES.SpreadElement) return;
+
+        // Only base 10: accept a missing radix or an explicit literal `10`.
+        if (args.length >= 2) {
+          const radix = args[1];
+
+          if (radix?.type !== AST_NODE_TYPES.Literal || radix.value !== 10) {
+            return;
+          }
+        }
+
+        // The argument must be a `string` so the autofix is type-safe against
+        // `Num.safeParseInt(s: string)`. Without type information, skip.
+        if (services?.program == null) return;
+
+        const checker = services.program.getTypeChecker();
+
+        const tsNode = services.esTreeNodeToTSNodeMap?.get(firstArg);
+
+        if (tsNode === undefined) return;
+
+        const argType = checker.getTypeAtLocation(tsNode);
+
+        if (!isStringType(argType)) return;
+
+        mut_nodesToFix.push({ node, argExpression: firstArg });
+      },
+      'Program:exit': () => {
+        const namedImports = getNamedImports(tsDataForgeImport);
+
+        const missingImports = (['Num', 'Result'] as const).filter(
+          (name) => !namedImports.includes(name),
+        );
+
+        for (const [
+          index,
+          { node, argExpression },
+        ] of mut_nodesToFix.entries()) {
+          const argText = sourceCode.getText(argExpression);
+
+          const originalText = sourceCode.getText(node);
+
+          context.report({
+            node,
+            messageId: 'useSafeParseInt',
+            data: {
+              original: originalText,
+              argName: argText,
+            },
+            fix: (fixer) => {
+              const core = `Result.unwrapOkOr(Num.safeParseInt(${argText}), Number.NaN)`;
+
+              const importFixes =
+                index === 0 && missingImports.length > 0
+                  ? buildImportFixes(
+                      fixer,
+                      program,
+                      tsDataForgeImport,
+                      missingImports,
+                    )
+                  : [];
+
+              return [...importFixes, fixer.replaceText(node, core)];
+            },
+          });
+        }
+      },
+    };
+  },
+  defaultOptions: [],
+} as const;

package/src/rules/prefer-num-safe-parse-int.test.mts

@@ -0,0 +1,137 @@
+import parser from '@typescript-eslint/parser';
+import { RuleTester } from '@typescript-eslint/rule-tester';
+import dedent from 'dedent';
+import { preferNumSafeParseInt } from './prefer-num-safe-parse-int.mjs';
+
+const tester = new RuleTester({
+  languageOptions: {
+    parser,
+    parserOptions: {
+      ecmaVersion: 2020,
+      sourceType: 'module',
+      projectService: {
+        allowDefaultProject: ['*.ts*'],
+      },
+      tsconfigRootDir: `${import.meta.dirname}/../..`,
+    },
+  },
+});
+
+describe('prefer-num-safe-parse-int', () => {
+  tester.run('prefer-num-safe-parse-int', preferNumSafeParseInt, {
+    valid: [
+      {
+        name: 'ignores non-base-10 radix',
+        code: dedent`
+          const s = "ff";
+          const n = parseInt(s, 16);
+        `,
+      },
+      {
+        name: 'ignores number arguments (autofix would be unsafe)',
+        code: dedent`
+          const x = 42;
+          const n = parseInt(x, 10);
+        `,
+      },
+      {
+        name: 'ignores never-typed arguments',
+        code: dedent`
+          declare const x: string & number;
+          const n = parseInt(x, 10);
+        `,
+      },
+      {
+        name: 'ignores unrelated calls',
+        code: dedent`
+          const s = "1";
+          const n = Number(s);
+        `,
+      },
+    ],
+    invalid: [
+      {
+        name: 'replaces parseInt(s, 10) and imports Num + Result',
+        code: dedent`
+          const s = "123";
+          const n = parseInt(s, 10);
+        `,
+        output: dedent`
+          import { Num, Result } from 'ts-data-forge';
+          const s = "123";
+          const n = Result.unwrapOkOr(Num.safeParseInt(s), Number.NaN);
+        `,
+        errors: [{ messageId: 'useSafeParseInt' }],
+      },
+      {
+        name: 'replaces parseInt(s) without radix',
+        code: dedent`
+          const s = "123";
+          const n = parseInt(s);
+        `,
+        output: dedent`
+          import { Num, Result } from 'ts-data-forge';
+          const s = "123";
+          const n = Result.unwrapOkOr(Num.safeParseInt(s), Number.NaN);
+        `,
+        errors: [{ messageId: 'useSafeParseInt' }],
+      },
+      {
+        name: 'replaces Number.parseInt(s, 10)',
+        code: dedent`
+          const s = "123";
+          const n = Number.parseInt(s, 10);
+        `,
+        output: dedent`
+          import { Num, Result } from 'ts-data-forge';
+          const s = "123";
+          const n = Result.unwrapOkOr(Num.safeParseInt(s), Number.NaN);
+        `,
+        errors: [{ messageId: 'useSafeParseInt' }],
+      },
+      {
+        name: 'adds only the missing Result import when Num is present',
+        code: dedent`
+          import { Num } from 'ts-data-forge';
+
+          const s = "123";
+          const n = parseInt(s, 10);
+        `,
+        output: dedent`
+          import { Result } from 'ts-data-forge';
+          import { Num } from 'ts-data-forge';
+
+          const s = "123";
+          const n = Result.unwrapOkOr(Num.safeParseInt(s), Number.NaN);
+        `,
+        errors: [{ messageId: 'useSafeParseInt' }],
+      },
+      {
+        name: 'wraps in parentheses in an operator context',
+        code: dedent`
+          const s = "123";
+          const ok = parseInt(s, 10) > 5;
+        `,
+        output: dedent`
+          import { Num, Result } from 'ts-data-forge';
+          const s = "123";
+          const ok = Result.unwrapOkOr(Num.safeParseInt(s), Number.NaN) > 5;
+        `,
+        errors: [{ messageId: 'useSafeParseInt' }],
+      },
+      {
+        name: 'preserves a complex string argument expression',
+        code: dedent`
+          const get = (k: string): string => k;
+          const n = parseInt(get("x").trim(), 10);
+        `,
+        output: dedent`
+          import { Num, Result } from 'ts-data-forge';
+          const get = (k: string): string => k;
+          const n = Result.unwrapOkOr(Num.safeParseInt(get("x").trim()), Number.NaN);
+        `,
+        errors: [{ messageId: 'useSafeParseInt' }],
+      },
+    ],
+  });
+}, 20000);

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

@@ -0,0 +1,179 @@
+import {
+  AST_NODE_TYPES,
+  type TSESLint,
+  type TSESTree,
+} from '@typescript-eslint/utils';
+import { Arr } from 'ts-data-forge';
+import {
+  buildImportFixes,
+  getNamedImports,
+  getTsDataForgeImport,
+} from './import-utils.mjs';
+
+type Options = readonly [];
+
+type MessageIds = 'useRangeForLoop';
+
+export const preferRangeForLoop: TSESLint.RuleModule<MessageIds, Options> = {
+  meta: {
+    type: 'suggestion',
+    docs: {
+      description:
+        'Replace `for (let i = begin; i < end; ++i)` with `for (const i of range(begin, end))` from ts-data-forge.',
+    },
+    fixable: 'code',
+    schema: [],
+    messages: {
+      useRangeForLoop:
+        'Replace with `for (const {{varName}} of range({{begin}}, {{end}}))` from ts-data-forge.',
+    },
+  },
+
+  create: (context) => {
+    const sourceCode = context.sourceCode;
+
+    const program = sourceCode.ast;
+
+    const tsDataForgeImport = getTsDataForgeImport(program);
+
+    const mut_nodesToFix: {
+      node: TSESTree.ForStatement;
+      varName: string;
+      begin: string;
+      end: string;
+      step?: string;
+    }[] = [];
+
+    return {
+      ForStatement: (node) => {
+        // Check init: let i = begin
+        if (
+          node.init?.type !== AST_NODE_TYPES.VariableDeclaration ||
+          node.init.kind !== 'let' ||
+          !Arr.isFixedLengthTuple(node.init.declarations, 1)
+        ) {
+          return;
+        }
+
+        const declaration = node.init.declarations[0];
+
+        if (
+          declaration.id.type !== AST_NODE_TYPES.Identifier ||
+          declaration.init === null
+        ) {
+          return;
+        }
+
+        const varName = declaration.id.name;
+
+        const beginExpr = declaration.init;
+
+        // Check test: i < end
+        if (
+          node.test?.type !== AST_NODE_TYPES.BinaryExpression ||
+          node.test.operator !== '<' ||
+          node.test.left.type !== AST_NODE_TYPES.Identifier ||
+          node.test.left.name !== varName
+        ) {
+          return;
+        }
+
+        const endExpr = node.test.right;
+
+        // Check update: ++i, i++, i += 1, or i += step
+        if (node.update === null) return;
+
+        let mut_step: string | undefined;
+
+        if (node.update.type === AST_NODE_TYPES.UpdateExpression) {
+          // ++i or i++
+          if (
+            node.update.operator === '++' &&
+            node.update.argument.type === AST_NODE_TYPES.Identifier &&
+            node.update.argument.name === varName
+          ) {
+            mut_step = undefined; // step defaults to 1
+          } else {
+            return;
+          }
+        } else if (
+          node.update.type === AST_NODE_TYPES.AssignmentExpression &&
+          node.update.operator === '+=' &&
+          node.update.left.type === AST_NODE_TYPES.Identifier &&
+          node.update.left.name === varName
+        ) {
+          // i += step
+          const stepValue = node.update.right;
+
+          if (stepValue.type === AST_NODE_TYPES.Literal) {
+            const stepNum = stepValue.value;
+
+            // Only support positive integer steps
+            if (typeof stepNum === 'number' && stepNum > 0) {
+              mut_step = stepNum === 1 ? undefined : String(stepNum);
+            } else {
+              return;
+            }
+          } else {
+            // Variable step like i += step
+            mut_step = sourceCode.getText(stepValue);
+          }
+        } else {
+          return;
+        }
+
+        const beginText = sourceCode.getText(beginExpr);
+
+        const endText = sourceCode.getText(endExpr);
+
+        mut_nodesToFix.push({
+          node,
+          varName,
+          begin: beginText,
+          end: endText,
+          step: mut_step,
+        });
+      },
+      'Program:exit': () => {
+        const namedImports = getNamedImports(tsDataForgeImport);
+
+        const hasRangeImport = namedImports.includes('range');
+
+        for (const [
+          index,
+          { node, varName, begin, end, step },
+        ] of mut_nodesToFix.entries()) {
+          context.report({
+            node: node.init ?? node,
+            messageId: 'useRangeForLoop',
+            data: {
+              varName,
+              begin,
+              end,
+            },
+            fix: (fixer) => {
+              const bodyText = sourceCode.getText(node.body);
+
+              const rangeArgs =
+                step === undefined
+                  ? `${begin}, ${end}`
+                  : `${begin}, ${end}, ${step}`;
+
+              const replacement = `for (const ${varName} of range(${rangeArgs})) ${bodyText}`;
+
+              const importFixes =
+                index === 0 && !hasRangeImport
+                  ? buildImportFixes(fixer, program, tsDataForgeImport, [
+                      'range',
+                    ])
+                  : [];
+
+              return [...importFixes, fixer.replaceText(node, replacement)];
+            },
+          });
+        }
+      },
+    };
+  },
+  defaultOptions: [],
+} as const;

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

@@ -0,0 +1,156 @@
+import parser from '@typescript-eslint/parser';
+import { RuleTester } from '@typescript-eslint/rule-tester';
+import dedent from 'dedent';
+import { preferRangeForLoop } from './prefer-range-for-loop.mjs';
+
+const tester = new RuleTester({
+  languageOptions: {
+    parser,
+    parserOptions: {
+      ecmaVersion: 2020,
+      sourceType: 'module',
+      projectService: {
+        allowDefaultProject: ['*.ts*'],
+      },
+      tsconfigRootDir: `${import.meta.dirname}/../..`,
+    },
+  },
+});
+
+describe('prefer-range-for-loop', () => {
+  tester.run('prefer-range-for-loop', preferRangeForLoop, {
+    valid: [
+      {
+        name: 'ignores for loop with const',
+        code: dedent`
+          for (const i = 0; i < 10; ++i) {
+            console.log(i);
+          }
+        `,
+      },
+      {
+        name: 'ignores for loop with different condition',
+        code: dedent`
+          for (let i = 0; i <= 10; ++i) {
+            console.log(i);
+          }
+        `,
+      },
+    ],
+    invalid: [
+      {
+        name: 'replaces for loop with ++i',
+        code: dedent`
+          for (let i = 0; i < 10; ++i) {
+            console.log(i);
+          }
+        `,
+        output: dedent`
+          import { range } from 'ts-data-forge';
+          for (const i of range(0, 10)) {
+            console.log(i);
+          }
+        `,
+        errors: [{ messageId: 'useRangeForLoop' }],
+      },
+      {
+        name: 'replaces for loop with i++',
+        code: dedent`
+          for (let i = 0; i < 10; i++) {
+            console.log(i);
+          }
+        `,
+        output: dedent`
+          import { range } from 'ts-data-forge';
+          for (const i of range(0, 10)) {
+            console.log(i);
+          }
+        `,
+        errors: [{ messageId: 'useRangeForLoop' }],
+      },
+      {
+        name: 'replaces for loop with i += 1',
+        code: dedent`
+          for (let i = 0; i < 10; i += 1) {
+            console.log(i);
+          }
+        `,
+        output: dedent`
+          import { range } from 'ts-data-forge';
+          for (const i of range(0, 10)) {
+            console.log(i);
+          }
+        `,
+        errors: [{ messageId: 'useRangeForLoop' }],
+      },
+      {
+        name: 'replaces for loop with variable bounds',
+        code: dedent`
+          const begin = 5;
+          const end = 15;
+          for (let j = begin; j < end; ++j) {
+            console.log(j);
+          }
+        `,
+        output: dedent`
+          import { range } from 'ts-data-forge';
+          const begin = 5;
+          const end = 15;
+          for (const j of range(begin, end)) {
+            console.log(j);
+          }
+        `,
+        errors: [{ messageId: 'useRangeForLoop' }],
+      },
+      // {
+      //   name: 'replaces for loop with different condition',
+      //   code: dedent`
+      //     for (let i = 0; i <= 10; ++i) {
+      //       console.log(i);
+      //     }
+      //   `,
+      //   output: dedent`
+      //     import { range } from 'ts-data-forge';
+      //     for (const i of range(0, 11)) {
+      //       console.log(i);
+      //     }
+      //   `,
+      //   errors: [{ messageId: 'useRangeForLoop' }],
+      // },
+      {
+        name: 'replaces for loop with i += 2',
+        code: dedent`
+          for (let i = 0; i < 10; i += 2) {
+            console.log(i);
+          }
+        `,
+        output: dedent`
+          import { range } from 'ts-data-forge';
+          for (const i of range(0, 10, 2)) {
+            console.log(i);
+          }
+        `,
+        errors: [{ messageId: 'useRangeForLoop' }],
+      },
+
+      {
+        name: 'keeps existing range import',
+        code: dedent`
+          import { range } from 'ts-data-forge';
+
+          for (let i = 0; i < 10; ++i) {
+            console.log(i);
+          }
+        `,
+        output: dedent`
+          import { range } from 'ts-data-forge';
+
+          for (const i of range(0, 10)) {
+            console.log(i);
+          }
+        `,
+        errors: [{ messageId: 'useRangeForLoop' }],
+      },
+    ],
+  });
+}, 20000);

package/src/rules/rules.mts

@@ -0,0 +1,36 @@
+import { type ESLintPlugin } from '../types.mjs';
+import { noUnnecessaryTypeGuard } from './no-unnecessary-type-guard.mjs';
+import { preferArrIsArray } from './prefer-arr-is-array.mjs';
+import { preferArrIsBoundedLengthArray } from './prefer-arr-is-bounded-length-array.mjs';
+import { preferArrIsFixedLengthArray } from './prefer-arr-is-fixed-length-array.mjs';
+import { preferArrIsMaxLengthArray } from './prefer-arr-is-max-length-array.mjs';
+import { preferArrIsMinLengthArray } from './prefer-arr-is-min-length-array.mjs';
+import { preferArrIsNonEmpty } from './prefer-arr-is-non-empty.mjs';
+import { preferArrSum } from './prefer-arr-sum.mjs';
+import { preferAsInt } from './prefer-as-int.mjs';
+import { preferCanonicalArraySlicing } from './prefer-canonical-array-slicing.mjs';
+import { preferComparisonOverNullishGuard } from './prefer-comparison-over-nullish-guard.mjs';
+import { preferIsNonNullObject } from './prefer-is-non-null-object.mjs';
+import { preferIsRecordAndHasKey } from './prefer-is-record-and-has-key.mjs';
+import { preferNumSafeParseFloat } from './prefer-num-safe-parse-float.mjs';
+import { preferNumSafeParseInt } from './prefer-num-safe-parse-int.mjs';
+import { preferRangeForLoop } from './prefer-range-for-loop.mjs';
+
+export const tsDataForgeRules = {
+  'prefer-canonical-array-slicing': preferCanonicalArraySlicing,
+  'prefer-arr-is-min-length-array': preferArrIsMinLengthArray,
+  'prefer-arr-is-max-length-array': preferArrIsMaxLengthArray,
+  'prefer-arr-is-bounded-length-array': preferArrIsBoundedLengthArray,
+  'prefer-arr-is-fixed-length-array': preferArrIsFixedLengthArray,
+  'prefer-arr-is-array': preferArrIsArray,
+  'prefer-arr-is-non-empty': preferArrIsNonEmpty,
+  'prefer-arr-sum': preferArrSum,
+  'prefer-as-int': preferAsInt,
+  'prefer-is-non-null-object': preferIsNonNullObject,
+  'prefer-range-for-loop': preferRangeForLoop,
+  'prefer-is-record-and-has-key': preferIsRecordAndHasKey,
+  'prefer-num-safe-parse-int': preferNumSafeParseInt,
+  'prefer-num-safe-parse-float': preferNumSafeParseFloat,
+  'no-unnecessary-type-guard': noUnnecessaryTypeGuard,
+  'prefer-comparison-over-nullish-guard': preferComparisonOverNullishGuard,
+} as const satisfies ESLintPlugin['rules'];

package/src/types.mts

@@ -0,0 +1,4 @@
+import { type TSESLint } from '@typescript-eslint/utils';
+import { type DeepReadonly } from 'ts-type-forge';
+
+export type ESLintPlugin = DeepReadonly<TSESLint.FlatConfig.Plugin>;