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

package/src/rules/prefer-is-record-and-has-key.mts

@@ -1,320 +1,6 @@
-import {
-  AST_NODE_TYPES,
-  type TSESLint,
-  type TSESTree,
-} from '@typescript-eslint/utils';
-import {
-  buildNamedImportFix,
-  getArgumentText,
-  getImportDeclarations,
-  getNamedImports,
-  skipTypeWrappers,
-} from 'eslint-rule-forge';
-import { Arr } from 'ts-data-forge';
-import * as ts from 'typescript';
-import { isIdentifierNamed, typeHoldsAtEveryLayer } from './ast-utils.mjs';
+import { createPreferIsRecordAndHasKey } from 'eslint-rule-forge';
 import { TS_DATA_FORGE_MODULE } from './constants.mjs';
 
-type Options = readonly [];
-
-type MessageIds = 'useIsRecordAndHasKey' | 'useHasKey';
-
-export const preferIsRecordAndHasKey: TSESLint.RuleModule<MessageIds, Options> =
-  {
-    meta: {
-      type: 'suggestion',
-      docs: {
-        description:
-          'Replace `Object.hasOwn(obj, key)` or `key in obj` with `isRecord(obj) && hasKey(obj, key)` from ts-data-forge',
-      },
-      fixable: 'code',
-      schema: [],
-      messages: {
-        useIsRecordAndHasKey:
-          'Replace `{{original}}` with `isRecord({{objName}}) && hasKey({{objName}}, {{keyName}})` from ts-data-forge.',
-        useHasKey:
-          'Replace `{{original}}` with `hasKey({{objName}}, {{keyName}})` from ts-data-forge.',
-      },
-    },
-
-    create: (context) => {
-      const sourceCode = context.sourceCode;
-
-      const program = sourceCode.ast;
-
-      const tsDataForgeImports = getImportDeclarations(
-        program,
-        TS_DATA_FORGE_MODULE,
-      );
-
-      /**
-       * Whether the `isRecord(...)` half of the rewrite would be dead code
-       * because the object already satisfies `hasKey`'s
-       * `R extends UnknownRecord` constraint, at every layer of type
-       * wrappers: an array cast to a record is still rejected by `isRecord`,
-       * and a record widened to one that may be an array is the author saying
-       * it may need the guard. Without type information nothing is known, so
-       * the guard is kept.
-       */
-      const isKnownRecord = (
-        // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-        expression: TSESTree.Expression,
-      ): boolean =>
-        typeHoldsAtEveryLayer(sourceCode, expression, (type, checker) =>
-          isAlreadyRecordType(checker, type),
-        );
-
-      /**
-       * Whether the object may be an array at some layer of type wrappers.
-       * `isRecord` rejects an array, so `'0' in xs` would turn from `true` to
-       * `false`; a widening cast to a type that may be an array is the author
-       * saying it may be one. Without type information nothing is known, and
-       * the rule reports as it always has.
-       */
-      const mayBeArray = (
-        // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-        expression: TSESTree.Expression,
-      ): boolean =>
-        sourceCode.parserServices?.program != null &&
-        !typeHoldsAtEveryLayer(
-          sourceCode,
-          expression,
-          (type, checker) => !mayBeArrayType(checker, type),
-        );
-
-      const mut_nodesToFix: {
-        node: TSESTree.CallExpression | TSESTree.BinaryExpression;
-        objExpression: TSESTree.Expression;
-        keyExpression: TSESTree.Expression;
-      }[] = [];
-
-      return {
-        // Handle Object.hasOwn(obj, key)
-        CallExpression: (node) => {
-          const callee = skipTypeWrappers(node.callee);
-
-          if (
-            callee.type !== AST_NODE_TYPES.MemberExpression ||
-            !isIdentifierNamed(callee.object, 'Object') ||
-            callee.property.type !== AST_NODE_TYPES.Identifier ||
-            callee.property.name !== 'hasOwn'
-          ) {
-            return;
-          }
-
-          // Check arguments: Object.hasOwn(obj, key)
-          if (node.arguments.length !== 2) {
-            return;
-          }
-
-          const objArg = node.arguments[0];
-
-          const keyArg = node.arguments[1];
-
-          if (objArg === undefined || keyArg === undefined) {
-            return;
-          }
-
-          // Type guard: ensure arguments are Expressions (not SpreadElement)
-          if (
-            objArg.type === AST_NODE_TYPES.SpreadElement ||
-            keyArg.type === AST_NODE_TYPES.SpreadElement ||
-            mayBeArray(objArg)
-          ) {
-            return;
-          }
-
-          mut_nodesToFix.push({
-            node,
-            objExpression: objArg,
-            keyExpression: keyArg,
-          });
-        },
-
-        // Handle key in obj
-        BinaryExpression: (node) => {
-          if (node.operator !== 'in') {
-            return;
-          }
-
-          const keyExpression = node.left;
-
-          const objExpression = node.right;
-
-          // Type guard: ensure keyExpression is Expression (not PrivateIdentifier)
-          if (
-            keyExpression.type === AST_NODE_TYPES.PrivateIdentifier ||
-            mayBeArray(objExpression)
-          ) {
-            return;
-          }
-
-          mut_nodesToFix.push({
-            node,
-            objExpression,
-            keyExpression,
-          });
-        },
-
-        'Program:exit': () => {
-          const namedImports = getNamedImports(tsDataForgeImports);
-
-          const rewrites = mut_nodesToFix.map((entry) => {
-            // A record-typed object makes the `isRecord(...)` conjunct always
-            // true, so it is left out of the replacement entirely.
-            const needsIsRecord = !isKnownRecord(entry.objExpression);
-
-            return {
-              ...entry,
-              needsIsRecord,
-              // `isRecord(obj) && hasKey(obj, key)` evaluates `obj` twice.
-              fixable: !needsIsRecord || isSideEffectFree(entry.objExpression),
-            };
-          });
-
-          const fixableRewrites = rewrites.filter(({ fixable }) => fixable);
-
-          const importsToAdd: readonly string[] = Arr.isEmpty(fixableRewrites)
-            ? []
-            : [
-                ...(fixableRewrites.some(
-                  ({ needsIsRecord }) => needsIsRecord,
-                ) && !namedImports.includes('isRecord')
-                  ? ['isRecord']
-                  : []),
-                ...(namedImports.includes('hasKey') ? [] : ['hasKey']),
-              ];
-
-          const importCarrier = fixableRewrites[0];
-
-          for (const rewrite of rewrites) {
-            const { node, objExpression, keyExpression, needsIsRecord } =
-              rewrite;
-
-            const objText = getArgumentText(sourceCode, objExpression);
-
-            const keyText = getArgumentText(sourceCode, keyExpression);
-
-            const originalText = sourceCode.getText(node);
-
-            context.report({
-              node,
-              messageId: needsIsRecord ? 'useIsRecordAndHasKey' : 'useHasKey',
-              data: {
-                original: originalText,
-                objName: objText,
-                keyName: keyText,
-              },
-              fix: !rewrite.fixable
-                ? undefined
-                : (fixer) => {
-                    const replacement = needsIsRecord
-                      ? `(isRecord(${objText}) && hasKey(${objText}, ${keyText}))`
-                      : `hasKey(${objText}, ${keyText})`;
-
-                    // All import fixes have to live on the first fixable
-                    // report: `insertTextBefore(program, …)` produces
-                    // overlapping ranges otherwise and only one of them would
-                    // survive a pass.
-                    const importFixes =
-                      rewrite === importCarrier && importsToAdd.length > 0
-                        ? buildNamedImportFix(
-                            fixer,
-                            program,
-                            TS_DATA_FORGE_MODULE,
-                            importsToAdd,
-                          )
-                        : [];
-
-                    return [
-                      ...importFixes,
-                      fixer.replaceText(node, replacement),
-                    ];
-                  },
-            });
-          }
-        },
-      };
-    },
-    defaultOptions: [],
-  } as const;
-
-/**
- * Whether reading `node` again has no side effects: a variable, `this`, or a
- * non-computed property chain on one, type wrappers aside.
- */
-const isSideEffectFree = (
-  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-  wrapped: TSESTree.Node,
-): boolean => {
-  const node = skipTypeWrappers(wrapped);
-
-  return (
-    node.type === AST_NODE_TYPES.Identifier ||
-    node.type === AST_NODE_TYPES.ThisExpression ||
-    (node.type === AST_NODE_TYPES.MemberExpression &&
-      !node.computed &&
-      isSideEffectFree(node.object))
-  );
-};
-
-/**
- * Whether a value of `type` may be an array or a tuple: some member of a union
- * or an intersection is one, or the constraint of a deferred type is.
- * `object` and `unknown` say nothing either way and are not counted.
- */
-const mayBeArrayType = (
-  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-  checker: ts.TypeChecker,
-  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-  type: ts.Type,
-): boolean => {
-  if (type.isUnionOrIntersection()) {
-    return type.types.some((member) => mayBeArrayType(checker, member));
-  }
-
-  if (
-    (type.flags &
-      (ts.TypeFlags.TypeParameter |
-        ts.TypeFlags.IndexedAccess |
-        ts.TypeFlags.Conditional |
-        ts.TypeFlags.Substitution)) !==
-    0
-  ) {
-    const constraint = checker.getBaseConstraintOfType(type);
-
-    return constraint !== undefined && mayBeArrayType(checker, constraint);
-  }
-
-  return checker.isArrayType(type) || checker.isTupleType(type);
-};
-
-/**
- * Whether `type` already satisfies `hasKey`'s `R extends UnknownRecord`
- * constraint, so that guarding the call with `isRecord` adds nothing.
- *
- * `UnknownRecord` is `ReadonlyRecord<string, unknown>`, so a string index
- * signature is exactly what it asks for and its value type is `unknown`, which
- * anything satisfies. Callables and arrays are excluded because `isRecord`
- * rejects them at runtime (`typeof fn === 'object'` is false, `Array.isArray`
- * is true), so dropping the guard there would change behavior.
- *
- * Deliberately conservative: a type TypeScript would accept through an
- * *implicit* index signature (an object type alias without one of its own)
- * keeps the guard, because the checker does not report such a signature here.
- */
-const isAlreadyRecordType = (
-  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-  checker: ts.TypeChecker,
-  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-  type: ts.Type,
-): boolean =>
-  type.isUnion()
-    ? type.types.every((member) => isAlreadyRecordType(checker, member))
-    : checker.getIndexInfoOfType(type, ts.IndexKind.String) !== undefined &&
-      Arr.isEmpty(checker.getSignaturesOfType(type, ts.SignatureKind.Call)) &&
-      Arr.isEmpty(
-        checker.getSignaturesOfType(type, ts.SignatureKind.Construct),
-      ) &&
-      !checker.isArrayType(type) &&
-      !checker.isTupleType(type);
+export const preferIsRecordAndHasKey = createPreferIsRecordAndHasKey({
+  moduleName: TS_DATA_FORGE_MODULE,
+});

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

@@ -1,195 +1,8 @@
-import {
-  AST_NODE_TYPES,
-  type TSESLint,
-  type TSESTree,
-} from '@typescript-eslint/utils';
-import {
-  buildNamedImportFix,
-  getArgumentText,
-  getImportDeclarations,
-  getNamedImports,
-  typeWrapperLayers,
-} from 'eslint-rule-forge';
-import * as ts from 'typescript';
+import { createPreferSafeParseFloat } from 'eslint-rule-forge';
 import { TS_DATA_FORGE_MODULE } from './constants.mjs';
 
-type Options = readonly [];
-
-type MessageIds = 'useSafeParseFloat';
-
-/**
- * Returns `true` when every constituent of `type` is string-like, i.e. the
- * type is assignable to the `string` parameter of `Num.safeParseFloat`. 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 `parseFloat(x)`, `Number.parseFloat(x)`, and `Number(x)` (when x
- * is typed as `string`) and replaces them with
- * `Result.unwrapOkOr(Num.safeParseFloat(x), Number.NaN)` (ts-data-forge).
- *
- * `Number(x)` is only flagged when x is purely a string type to avoid false
- * positives for `Number(someBoolean)` or `Number(someNumber)` uses. The type is
- * asked of the value under any `as` / `!` / `satisfies` too, so a cast does not
- * vouch for a string that is not one.
- */
-export const preferNumSafeParseFloat: TSESLint.RuleModule<MessageIds, Options> =
-  {
-    meta: {
-      type: 'suggestion',
-      docs: {
-        description:
-          'Replace `parseFloat(x)`, `Number.parseFloat(x)`, or `Number(x)` (when x is a string) with `Result.unwrapOkOr(Num.safeParseFloat(x), Number.NaN)` from ts-data-forge.',
-      },
-      fixable: 'code',
-      schema: [],
-      messages: {
-        useSafeParseFloat:
-          'Replace `{{original}}` with `Result.unwrapOkOr(Num.safeParseFloat({{argName}}), Number.NaN)` from ts-data-forge.',
-      },
-    },
-
-    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: {
-        node: TSESTree.CallExpression;
-        argExpression: TSESTree.Expression;
-      }[] = [];
-
-      return {
-        CallExpression: (node) => {
-          const { callee } = node;
-
-          // Match `parseFloat(...)` (global function).
-          const isGlobalParseFloat =
-            callee.type === AST_NODE_TYPES.Identifier &&
-            callee.name === 'parseFloat';
-
-          // Match `Number.parseFloat(...)`.
-          const isNumberParseFloat =
-            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 === 'parseFloat';
-
-          // Match `Number(...)` called as a function (not `new Number(...)`).
-          const isNumberCall =
-            callee.type === AST_NODE_TYPES.Identifier &&
-            callee.name === 'Number';
-
-          if (!isGlobalParseFloat && !isNumberParseFloat && !isNumberCall) {
-            return;
-          }
-
-          const args = node.arguments;
-
-          const firstArg = args[0];
-
-          if (firstArg === undefined) {
-            return;
-          }
-
-          // Spread argument (`parseFloat(...rest)`) cannot be rewritten safely.
-          if (firstArg.type === AST_NODE_TYPES.SpreadElement) {
-            return;
-          }
-
-          // The argument must be purely `string` so the autofix is type-safe
-          // against `Num.safeParseFloat(s: string)`. Without type information,
-          // skip.
-          if (services?.program == null) {
-            return;
-          }
-
-          const checker = services.program.getTypeChecker();
-
-          // Every layer of type wrappers must be `string` (see
-          // typeWrapperLayers): the value underneath is what `Number` sees at
-          // run time (`Number(v as string)` may still be handed `true`), and
-          // the type a wrapper states is what the fix, which keeps the
-          // wrapper, passes on.
-          const isString = (
-            // AST nodes hold mutable child arrays, so they are not deeply readonly.
-            // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-            expression: TSESTree.Node,
-          ): boolean => {
-            const tsNode = services.esTreeNodeToTSNodeMap?.get(expression);
-
-            return (
-              tsNode !== undefined &&
-              isStringType(checker.getTypeAtLocation(tsNode))
-            );
-          };
-
-          if (!typeWrapperLayers(firstArg).every(isString)) {
-            return;
-          }
-
-          mut_nodesToFix.push({ node, argExpression: firstArg });
-        },
-        'Program:exit': () => {
-          const namedImports = getNamedImports(tsDataForgeImports);
-
-          const missingImports = (['Num', 'Result'] as const).filter(
-            (name) => !namedImports.includes(name),
-          );
-
-          for (const [
-            index,
-            { node, argExpression },
-          ] of mut_nodesToFix.entries()) {
-            const argText = getArgumentText(sourceCode, argExpression);
-
-            const originalText = sourceCode.getText(node);
-
-            context.report({
-              node,
-              messageId: 'useSafeParseFloat',
-              data: {
-                original: originalText,
-                argName: argText,
-              },
-              fix: (fixer) => {
-                const core = `Result.unwrapOkOr(Num.safeParseFloat(${argText}), Number.NaN)`;
-
-                const importFixes =
-                  index === 0 && missingImports.length > 0
-                    ? buildNamedImportFix(
-                        fixer,
-                        program,
-                        TS_DATA_FORGE_MODULE,
-                        missingImports,
-                      )
-                    : [];
-
-                return [...importFixes, fixer.replaceText(node, core)];
-              },
-            });
-          }
-        },
-      };
-    },
-    defaultOptions: [],
-  } as const;
+export const preferNumSafeParseFloat = createPreferSafeParseFloat({
+  moduleName: TS_DATA_FORGE_MODULE,
+  namespace: 'Num',
+  method: 'safeParseFloat',
+});

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

@@ -214,6 +214,24 @@ describe('prefer-num-safe-parse-float through type wrappers', () => {
           { messageId: 'useSafeParseFloat' },
         ],
       },
+      {
+        name: 'the callee read through `as` and `!`',
+        code: dedent`
+          declare const s: string;
+          const a = (Number as NumberConstructor)(s);
+          const b = Number!.parseFloat(s);
+        `,
+        output: dedent`
+          import { Num, Result } from 'ts-data-forge';
+          declare const s: string;
+          const a = Result.unwrapOkOr(Num.safeParseFloat(s), Number.NaN);
+          const b = Result.unwrapOkOr(Num.safeParseFloat(s), Number.NaN);
+        `,
+        errors: [
+          { messageId: 'useSafeParseFloat' },
+          { messageId: 'useSafeParseFloat' },
+        ],
+      },
     ],
   });
 }, 20000);