eslint-rule-forge 0.2.0 → 0.3.0

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

@@ -0,0 +1,119 @@
+import {
+  AST_NODE_TYPES,
+  type TSESLint,
+  type TSESTree,
+} from '@typescript-eslint/utils';
+import {
+  buildNamedImportFix,
+  getImportDeclarations,
+  getNamedImports,
+} from '../imports.mjs';
+import { getRangeWithParens } from '../parentheses.mjs';
+import { isIdentifierNamed, skipTypeWrappers } from '../type-wrappers.mjs';
+
+/**
+ * Builds a rule that replaces `Array.isArray` with `<namespace>.isArray`
+ * imported from `moduleName`. Only the callee is rewritten; the arguments stay
+ * as written.
+ */
+export const createPreferArrayIsArray = ({
+  moduleName,
+  namespace,
+}: Readonly<{
+  /** The module that exports `namespace`. */
+  moduleName: string;
+
+  /** The exported namespace whose `isArray` replaces `Array.isArray`. */
+  namespace: string;
+}>): TSESLint.RuleModule<'useIsArray', readonly []> => {
+  const replacement = `${namespace}.isArray` as const;
+
+  const text =
+    `Replace \`Array.isArray\` with \`${replacement}\` from ${moduleName}.` as const;
+
+  return {
+    meta: {
+      type: 'suggestion',
+      docs: { description: text },
+      fixable: 'code',
+      schema: [],
+      messages: { useIsArray: text },
+    },
+
+    create: (context) => {
+      const sourceCode = context.sourceCode;
+
+      const program = sourceCode.ast;
+
+      const moduleImports = getImportDeclarations(program, moduleName);
+
+      const mut_nodesToFix: TSESTree.CallExpression[] = [];
+
+      return {
+        CallExpression: (node) => {
+          if (!isArrayIsArrayCall(node)) {
+            return;
+          }
+
+          mut_nodesToFix.push(node);
+        },
+        'Program:exit': () => {
+          const hasNamespaceImport =
+            getNamedImports(moduleImports).includes(namespace);
+
+          // The import fix lives on the first report only:
+          // `insertTextBefore(program, …)` produces overlapping ranges
+          // otherwise and only one of them would survive a pass. A first
+          // report silenced by an `eslint-disable` comment therefore takes
+          // the import with it.
+          for (const [index, node] of mut_nodesToFix.entries()) {
+            context.report({
+              node,
+              messageId: 'useIsArray',
+              fix: (fixer) => {
+                const importFixes =
+                  index === 0 && !hasNamespaceImport
+                    ? buildNamedImportFix(fixer, program, moduleName, [
+                        namespace,
+                      ])
+                    : ([] as const);
+
+                // Only the callee is replaced, type wrappers included, along
+                // with the parentheses around it, which its range leaves out;
+                // the arguments stay as written.
+                return [
+                  ...importFixes,
+                  fixer.replaceTextRange(
+                    getRangeWithParens(sourceCode, node.callee),
+                    replacement,
+                  ),
+                ];
+              },
+            });
+          }
+        },
+      };
+    },
+    defaultOptions: [],
+  } as const;
+};
+
+/**
+ * Whether `node` calls `Array.isArray`, the callee and `Array` both read
+ * through their type wrappers: `(Array as ArrayConstructor).isArray(x)` and
+ * `(Array.isArray as (u: unknown) => boolean)(x)` are the same call.
+ */
+const isArrayIsArrayCall = (
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  node: TSESTree.CallExpression,
+): boolean => {
+  const callee = skipTypeWrappers(node.callee);
+
+  return (
+    callee.type === AST_NODE_TYPES.MemberExpression &&
+    !callee.computed &&
+    isIdentifierNamed(callee.object, 'Array') &&
+    callee.property.type === AST_NODE_TYPES.Identifier &&
+    callee.property.name === 'isArray'
+  );
+};

package/src/rules/prefer-is-non-null-object.mts

@@ -0,0 +1,276 @@
+import {
+  AST_NODE_TYPES,
+  type TSESLint,
+  type TSESTree,
+} from '@typescript-eslint/utils';
+import {
+  buildNamedImportFix,
+  getImportDeclarations,
+  getNamedImports,
+} from '../imports.mjs';
+import { getRangeWithParens, parenthesesDepth } from '../parentheses.mjs';
+import { skipTypeWrappers } from '../type-wrappers.mjs';
+
+/**
+ * Builds a rule that replaces `typeof u === 'object' && u !== null`, in either
+ * order and anywhere in an `&&` chain, with `isNonNullObject(u)` imported from
+ * `moduleName`.
+ */
+export const createPreferIsNonNullObject = ({
+  moduleName,
+}: Readonly<{
+  /** The module that exports `isNonNullObject`. */
+  moduleName: string;
+}>): TSESLint.RuleModule<'useIsNonNullObject', readonly []> =>
+  ({
+    meta: {
+      type: 'suggestion',
+      docs: {
+        description: `Replace \`typeof u === "object" && u !== null\`, in either order and anywhere in an \`&&\` chain, with \`isNonNullObject(u)\` from ${moduleName}.`,
+      },
+      fixable: 'code',
+      schema: [],
+      messages: {
+        useIsNonNullObject: `Replace the object/null check with \`isNonNullObject()\` from ${moduleName}.`,
+      },
+    },
+
+    create: (context) => {
+      const sourceCode = context.sourceCode;
+
+      const program = sourceCode.ast;
+
+      const moduleImports = getImportDeclarations(program, moduleName);
+
+      const mut_pairsToFix: NonNullObjectPair[] = [];
+
+      return {
+        LogicalExpression: (node) => {
+          // A chain is read once, from its outermost `&&`.
+          if (node.operator !== '&&' || isChainOperand(sourceCode, node)) {
+            return;
+          }
+
+          mut_pairsToFix.push(...findNonNullObjectPairs(sourceCode, node));
+        },
+        'Program:exit': () => {
+          const hasIsNonNullObjectImport =
+            getNamedImports(moduleImports).includes('isNonNullObject');
+
+          // The import fix lives on the first report only:
+          // `insertTextBefore(program, …)` produces overlapping ranges
+          // otherwise and only one of them would survive a pass. A first
+          // report silenced by an `eslint-disable` comment therefore takes
+          // the import with it.
+          for (const [
+            index,
+            { range, identifierName },
+          ] of mut_pairsToFix.entries()) {
+            context.report({
+              loc: {
+                start: sourceCode.getLocFromIndex(range[0]),
+                end: sourceCode.getLocFromIndex(range[1]),
+              },
+              messageId: 'useIsNonNullObject',
+              fix: (fixer) => {
+                const replacement = `isNonNullObject(${identifierName})`;
+
+                const importFixes =
+                  index === 0 && !hasIsNonNullObjectImport
+                    ? buildNamedImportFix(fixer, program, moduleName, [
+                        'isNonNullObject',
+                      ])
+                    : [];
+
+                return [
+                  ...importFixes,
+                  fixer.replaceTextRange(range, replacement),
+                ];
+              },
+            });
+          }
+        },
+      };
+    },
+    defaultOptions: [],
+  }) as const;
+
+/**
+ * A `typeof u === 'object'` and a `u !== null` next to each other in an `&&`
+ * chain, as the source range from the first to the second (parentheses
+ * included) and the name of `u`.
+ */
+type NonNullObjectPair = Readonly<{
+  range: TSESTree.Range;
+  identifierName: string;
+}>;
+
+/**
+ * Whether `node` is an operand of an enclosing `&&` chain: a `&&` written
+ * directly under another one, without parentheses.
+ */
+const isChainOperand = (
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  sourceCode: TSESLint.SourceCode,
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  node: TSESTree.LogicalExpression,
+): boolean =>
+  node.parent.type === AST_NODE_TYPES.LogicalExpression &&
+  node.parent.operator === '&&' &&
+  parenthesesDepth(sourceCode, node) === 0;
+
+/**
+ * Every non-overlapping pair in the `&&` chain `node` heads, left to right. The
+ * two halves may come in either order, and the pair may have operands before
+ * and after it: `a && u !== null && typeof u === 'object' && b`. They have to
+ * be next to each other, so that the pair is one range of the source.
+ */
+const findNonNullObjectPairs = (
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  sourceCode: TSESLint.SourceCode,
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  node: TSESTree.LogicalExpression,
+): readonly NonNullObjectPair[] => {
+  const operands = chainOperands(sourceCode, node);
+
+  const pairsFrom = (index: number): readonly NonNullObjectPair[] => {
+    const first = operands[index];
+
+    const second = operands[index + 1];
+
+    if (first === undefined || second === undefined) {
+      return [];
+    }
+
+    const identifierName =
+      pairIdentifierName(first, second) ?? pairIdentifierName(second, first);
+
+    return identifierName === undefined
+      ? pairsFrom(index + 1)
+      : [
+          {
+            range: [
+              getRangeWithParens(sourceCode, first)[0],
+              getRangeWithParens(sourceCode, second)[1],
+            ],
+            identifierName,
+          },
+          ...pairsFrom(index + 2),
+        ];
+  };
+
+  return pairsFrom(0);
+};
+
+/**
+ * The operands of the `&&` chain `node`, left to right. A parenthesized `&&`
+ * is one operand: its halves cannot be replaced without its parentheses.
+ */
+const chainOperands = (
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  sourceCode: TSESLint.SourceCode,
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  node: TSESTree.LogicalExpression,
+): readonly TSESTree.Expression[] =>
+  [node.left, node.right].flatMap((operand) =>
+    operand.type === AST_NODE_TYPES.LogicalExpression &&
+    operand.operator === '&&' &&
+    parenthesesDepth(sourceCode, operand) === 0
+      ? chainOperands(sourceCode, operand)
+      : [operand],
+  );
+
+// Every operand below is read through its type wrappers: `typeof (u satisfies
+// unknown) === 'object' && u! !== null` is the same check.
+
+/**
+ * The name of `u` when `typeofCheck` is `typeof u === 'object'` and
+ * `nullCheck` is `u !== null` for the same `u`.
+ */
+const pairIdentifierName = (
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  typeofCheck: TSESTree.Expression,
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  nullCheck: TSESTree.Expression,
+): string | undefined => {
+  const identifierName = getTypeofObjectIdentifierName(
+    skipTypeWrappers(typeofCheck),
+  );
+
+  return identifierName !== undefined &&
+    identifierName ===
+      getNonNullCheckIdentifierName(skipTypeWrappers(nullCheck))
+    ? identifierName
+    : undefined;
+};
+
+/** `u` of `typeof u === 'object'`, in either operand order. */
+const getTypeofObjectIdentifierName = (
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  node: TSESTree.Node,
+): string | undefined => {
+  if (
+    node.type !== AST_NODE_TYPES.BinaryExpression ||
+    node.operator !== '==='
+  ) {
+    return undefined;
+  }
+
+  const left = skipTypeWrappers(node.left);
+
+  const right = skipTypeWrappers(node.right);
+
+  const typeofSide = isLiteralOf(right, 'object')
+    ? left
+    : isLiteralOf(left, 'object')
+      ? right
+      : undefined;
+
+  if (
+    typeofSide?.type !== AST_NODE_TYPES.UnaryExpression ||
+    typeofSide.operator !== 'typeof'
+  ) {
+    return undefined;
+  }
+
+  const argument = skipTypeWrappers(typeofSide.argument);
+
+  return argument.type === AST_NODE_TYPES.Identifier
+    ? argument.name
+    : undefined;
+};
+
+/**
+ * `u` of `u !== null`, in either operand order. `u != null` also excludes
+ * `undefined`, which `typeof u === 'object'` has already excluded, so it is
+ * the same check here.
+ */
+const getNonNullCheckIdentifierName = (
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  node: TSESTree.Node,
+): string | undefined => {
+  if (
+    node.type !== AST_NODE_TYPES.BinaryExpression ||
+    (node.operator !== '!==' && node.operator !== '!=')
+  ) {
+    return undefined;
+  }
+
+  const left = skipTypeWrappers(node.left);
+
+  const right = skipTypeWrappers(node.right);
+
+  const checked = isLiteralOf(right, null)
+    ? left
+    : isLiteralOf(left, null)
+      ? right
+      : undefined;
+
+  return checked?.type === AST_NODE_TYPES.Identifier ? checked.name : undefined;
+};
+
+const isLiteralOf = (
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  node: TSESTree.Node,
+  value: string | null,
+): boolean => node.type === AST_NODE_TYPES.Literal && node.value === value;