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

package/src/rules/ast-utils.mts

@@ -10,7 +10,6 @@ import {
   typeWrapperLayers,
 } from 'eslint-rule-forge';
 import type { DeepReadonly } from 'ts-type-forge';
-import type * as ts from 'typescript';
 
 const isIntegerLiteral = (node: DeepReadonly<TSESTree.Expression>): boolean =>
   node.type === AST_NODE_TYPES.Literal &&
@@ -265,53 +264,3 @@ const isVariableDefinition = (
   def: TSESLint.Scope.Definition,
 ): def is TSESLint.Scope.Definition & VariableDefinition =>
   (def.type as string) === 'Variable';
-
-/**
- * Whether `node`, read through its type wrappers, is the identifier `name`:
- * `Number`, `(Number as NumberConstructor)` and `Number!` are the same object.
- */
-export const isIdentifierNamed = (
-  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-  node: TSESTree.Node,
-  name: string,
-): boolean => {
-  const unwrapped = skipTypeWrappers(node);
-
-  return (
-    unwrapped.type === AST_NODE_TYPES.Identifier && unwrapped.name === name
-  );
-};
-
-/**
- * Whether `holds` is true of the type of every layer of type wrappers around
- * `node` (see {@link typeWrapperLayers}), outermost to innermost; `false`
- * without type information. A widening cast (`s as string | number`) is the
- * author saying the value may be more than it is, and is respected; a
- * narrowing one (`s!`, `v as unknown as string`) cannot vouch for what the
- * value's own type does not, and the fix, which keeps the wrapper, has to
- * type-check at every layer too.
- */
-export const typeHoldsAtEveryLayer = (
-  // 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.Node,
-  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-  holds: (type: ts.Type, typeChecker: ts.TypeChecker) => boolean,
-): boolean => {
-  const services = sourceCode.parserServices;
-
-  const checker = services?.program?.getTypeChecker();
-
-  if (checker === undefined) {
-    return false;
-  }
-
-  return typeWrapperLayers(node).every((layer) => {
-    const tsNode = services?.esTreeNodeToTSNodeMap?.get(layer);
-
-    return (
-      tsNode !== undefined && holds(checker.getTypeAtLocation(tsNode), checker)
-    );
-  });
-};

package/src/rules/no-side-effect-import.mts

@@ -1,11 +1,6 @@
-import type { TSESLint, TSESTree } from '@typescript-eslint/utils';
-import { Arr } from 'ts-data-forge';
+import { createNoSideEffectImport } from 'eslint-rule-forge';
 import { TS_DATA_FORGE_MODULE } from './constants.mjs';
 
-type Options = readonly [];
-
-type MessageIds = 'removeSideEffectImport';
-
 /**
  * `import 'ts-data-forge';` binds nothing and runs nothing: every export is a
  * pure value or function, and the package declares `sideEffects: false`, which
@@ -13,59 +8,10 @@ type MessageIds = 'removeSideEffectImport';
  * a side-effect import in the emitted JavaScript — that is the one kind it
  * never elides — so what is left is a module loaded for no reason, and a
  * bundler that trusts the flag drops it anyway.
- *
- * The rule matches the bare specifier exactly; an import of some other module
- * is none of its business.
  */
-export const noSideEffectImport: TSESLint.RuleModule<MessageIds, Options> = {
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description: `Remove a side-effect-only \`import '${TS_DATA_FORGE_MODULE}';\`, which binds no name and, the package being \`sideEffects: false\`, does nothing.`,
-    },
-    fixable: 'code',
-    schema: [],
-    messages: {
-      removeSideEffectImport: `\`import '${TS_DATA_FORGE_MODULE}';\` binds no name, and \`${TS_DATA_FORGE_MODULE}\` declares \`sideEffects: false\`, so loading it does nothing. Remove it, and import what you need by name.`,
-    },
-  },
-
-  create: (context) => ({
-    ImportDeclaration: (node) => {
-      if (
-        node.source.value !== TS_DATA_FORGE_MODULE ||
-        !Arr.isEmpty(node.specifiers)
-      ) {
-        return;
-      }
-
-      context.report({
-        node,
-        messageId: 'removeSideEffectImport',
-        fix: (fixer) => removeStatement(fixer, context.sourceCode, node),
-      });
-    },
-  }),
-  defaultOptions: [],
-} as const;
-
-/* eslint-disable @typescript-eslint/prefer-readonly-parameter-types */
-
-/**
- * Removes a statement along with the rest of its line, so that deleting it does
- * not leave a blank line where it was.
- */
-const removeStatement = (
-  fixer: TSESLint.RuleFixer,
-  sourceCode: TSESLint.SourceCode,
-  node: TSESTree.Node,
-): TSESLint.RuleFix => {
-  const restOfLine = /^[^\S\n]*\n/u.exec(
-    sourceCode.getText().slice(node.range[1]),
-  );
-
-  return fixer.removeRange([
-    node.range[0],
-    node.range[1] + (restOfLine?.[0].length ?? 0),
-  ]);
-};
+export const noSideEffectImport = createNoSideEffectImport({
+  moduleName: TS_DATA_FORGE_MODULE,
+  type: 'suggestion',
+  description: `Remove a side-effect-only \`import '${TS_DATA_FORGE_MODULE}';\`, which binds no name and, the package being \`sideEffects: false\`, does nothing.`,
+  message: `\`import '${TS_DATA_FORGE_MODULE}';\` binds no name, and \`${TS_DATA_FORGE_MODULE}\` declares \`sideEffects: false\`, so loading it does nothing. Remove it, and import what you need by name.`,
+});

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

@@ -1,124 +1,7 @@
-import {
-  AST_NODE_TYPES,
-  type TSESLint,
-  type TSESTree,
-} from '@typescript-eslint/utils';
-import {
-  buildNamedImportFix,
-  getImportDeclarations,
-  getNamedImports,
-  skipTypeWrappers,
-} from 'eslint-rule-forge';
+import { createPreferArrayIsArray } from 'eslint-rule-forge';
 import { TS_DATA_FORGE_MODULE } from './constants.mjs';
 
-type Options = readonly [];
-
-type MessageIds = 'useArrIsArray';
-
-export const preferArrIsArray: TSESLint.RuleModule<MessageIds, Options> = {
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description:
-        'Replace `Array.isArray` with `Arr.isArray` from ts-data-forge.',
-    },
-    fixable: 'code',
-    schema: [],
-    messages: {
-      useArrIsArray:
-        'Replace `Array.isArray` with `Arr.isArray` from ts-data-forge.',
-    },
-  },
-
-  create: (context) => {
-    const sourceCode = context.sourceCode;
-
-    const program = sourceCode.ast;
-
-    const tsDataForgeImports = getImportDeclarations(
-      program,
-      TS_DATA_FORGE_MODULE,
-    );
-
-    const mut_nodesToFix: TSESTree.CallExpression[] = [];
-
-    return {
-      CallExpression: (node) => {
-        if (!isArrayIsArrayCall(node)) {
-          return;
-        }
-
-        mut_nodesToFix.push(node);
-      },
-      'Program:exit': () => {
-        // Check if Arr is already imported
-        const hasArrImport =
-          getNamedImports(tsDataForgeImports).includes('Arr');
-
-        // Note: We add import only for the first node to avoid conflicts when
-        // multiple fixes try to insert at the same position. This means if the
-        // first node is disabled via eslint-disable comment, no import will be
-        // added.
-        for (const [index, node] of mut_nodesToFix.entries()) {
-          context.report({
-            node,
-            messageId: 'useArrIsArray',
-            fix: (fixer) => {
-              const callee = node.callee;
-
-              if (callee.type !== AST_NODE_TYPES.MemberExpression) {
-                return [];
-              }
-
-              // Only the callee is replaced: parentheses the source put around
-              // it are outside its range, and stay balanced.
-              // Add import only for the first node and only if not already imported
-              const importFixes =
-                index === 0 && !hasArrImport
-                  ? buildNamedImportFix(fixer, program, TS_DATA_FORGE_MODULE, [
-                      'Arr',
-                    ])
-                  : [];
-
-              return [...importFixes, fixer.replaceText(callee, 'Arr.isArray')];
-            },
-          });
-        }
-      },
-    };
-  },
-  defaultOptions: [],
-} as const;
-
-const isArrayIsArrayCall = (
-  // AST nodes hold mutable child arrays, so they are not deeply readonly.
-  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-  node: TSESTree.CallExpression,
-): boolean => {
-  if (node.callee.type !== AST_NODE_TYPES.MemberExpression) {
-    return false;
-  }
-
-  const { property } = node.callee;
-
-  // `(Array as ArrayConstructor).isArray` is still `Array.isArray`.
-  const object = skipTypeWrappers(node.callee.object);
-
-  if (object.type !== AST_NODE_TYPES.Identifier) {
-    return false;
-  }
-
-  if (object.name !== 'Array') {
-    return false;
-  }
-
-  if (property.type !== AST_NODE_TYPES.Identifier) {
-    return false;
-  }
-
-  if (property.name !== 'isArray') {
-    return false;
-  }
-
-  return true;
-};
+export const preferArrIsArray = createPreferArrayIsArray({
+  moduleName: TS_DATA_FORGE_MODULE,
+  namespace: 'Arr',
+});

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

@@ -20,6 +20,13 @@ ruleTester.run('prefer-arr-is-array', preferArrIsArray, {
         const result = obj.isArray(value);
       `,
     },
+    {
+      name: 'A computed member named by a variable is not `isArray`',
+      code: dedent`
+        declare const isArray: 'from';
+        const result = Array[isArray](value);
+      `,
+    },
   ],
   invalid: [
     {
@@ -31,7 +38,7 @@ ruleTester.run('prefer-arr-is-array', preferArrIsArray, {
         import { Arr } from 'ts-data-forge';
         const result = Arr.isArray(value);
       `,
-      errors: [{ messageId: 'useArrIsArray' }],
+      errors: [{ messageId: 'useIsArray' }],
     },
     {
       name: 'Arr imported by a second ts-data-forge declaration is not imported again',
@@ -45,7 +52,7 @@ ruleTester.run('prefer-arr-is-array', preferArrIsArray, {
         import { Arr } from 'ts-data-forge';
         const result = Arr.isArray(value);
       `,
-      errors: [{ messageId: 'useArrIsArray' }],
+      errors: [{ messageId: 'useIsArray' }],
     },
     {
       name: 'Replace Array.isArray with Arr.isArray when Arr is already imported',
@@ -57,7 +64,7 @@ ruleTester.run('prefer-arr-is-array', preferArrIsArray, {
         import { Arr } from 'ts-data-forge';
         const result = Arr.isArray(value);
       `,
-      errors: [{ messageId: 'useArrIsArray' }],
+      errors: [{ messageId: 'useIsArray' }],
     },
     {
       name: 'Replace multiple Array.isArray calls',
@@ -70,7 +77,7 @@ ruleTester.run('prefer-arr-is-array', preferArrIsArray, {
         const result1 = Arr.isArray(value1);
         const result2 = Arr.isArray(value2);
       `,
-      errors: [{ messageId: 'useArrIsArray' }, { messageId: 'useArrIsArray' }],
+      errors: [{ messageId: 'useIsArray' }, { messageId: 'useIsArray' }],
     },
   ],
 });
@@ -89,7 +96,31 @@ describe('prefer-arr-is-array through type wrappers', () => {
           import { Arr } from 'ts-data-forge';
           const result = Arr.isArray(value);
         `,
-        errors: [{ messageId: 'useArrIsArray' }],
+        errors: [{ messageId: 'useIsArray' }],
+      },
+      {
+        name: 'Array reached through `!`',
+        code: dedent`
+          import { Arr } from 'ts-data-forge';
+          const result = Array!.isArray(value);
+        `,
+        output: dedent`
+          import { Arr } from 'ts-data-forge';
+          const result = Arr.isArray(value);
+        `,
+        errors: [{ messageId: 'useIsArray' }],
+      },
+      {
+        name: 'the callee reached through `satisfies`',
+        code: dedent`
+          import { Arr } from 'ts-data-forge';
+          const result = (Array.isArray satisfies unknown)(value);
+        `,
+        output: dedent`
+          import { Arr } from 'ts-data-forge';
+          const result = Arr.isArray(value);
+        `,
+        errors: [{ messageId: 'useIsArray' }],
       },
     ],
   });
@@ -107,9 +138,21 @@ describe('prefer-arr-is-array with parenthesized operands', () => {
         `,
         output: dedent`
           import { Arr } from 'ts-data-forge';
-          const result = (Arr.isArray)(value);
+          const result = Arr.isArray(value);
+        `,
+        errors: [{ messageId: 'useIsArray' }],
+      },
+      {
+        name: 'a doubly parenthesized callee of an optional call',
+        code: dedent`
+          import { Arr } from 'ts-data-forge';
+          const result = ((Array.isArray))?.(value);
+        `,
+        output: dedent`
+          import { Arr } from 'ts-data-forge';
+          const result = Arr.isArray?.(value);
         `,
-        errors: [{ messageId: 'useArrIsArray' }],
+        errors: [{ messageId: 'useIsArray' }],
       },
     ],
   });

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

@@ -1,276 +1,6 @@
-import {
-  AST_NODE_TYPES,
-  type TSESLint,
-  type TSESTree,
-} from '@typescript-eslint/utils';
-import {
-  buildNamedImportFix,
-  getImportDeclarations,
-  getNamedImports,
-  getRangeWithParens,
-  parenthesesDepth,
-  skipTypeWrappers,
-} from 'eslint-rule-forge';
+import { createPreferIsNonNullObject } from 'eslint-rule-forge';
 import { TS_DATA_FORGE_MODULE } from './constants.mjs';
 
-type Options = readonly [];
-
-type MessageIds = 'useIsNonNullObject';
-
-export const preferIsNonNullObject: TSESLint.RuleModule<MessageIds, Options> = {
-  meta: {
-    type: 'suggestion',
-    docs: {
-      description:
-        'Replace `typeof u === "object" && u !== null`, in either order and anywhere in an `&&` chain, with `isNonNullObject(u)` from ts-data-forge.',
-    },
-    fixable: 'code',
-    schema: [],
-    messages: {
-      useIsNonNullObject:
-        'Replace the object/null check with `isNonNullObject()` from ts-data-forge.',
-    },
-  },
-
-  create: (context) => {
-    const sourceCode = context.sourceCode;
-
-    const program = sourceCode.ast;
-
-    const tsDataForgeImports = getImportDeclarations(
-      program,
-      TS_DATA_FORGE_MODULE,
-    );
-
-    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(tsDataForgeImports).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, TS_DATA_FORGE_MODULE, [
-                      '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;
+export const preferIsNonNullObject = createPreferIsNonNullObject({
+  moduleName: TS_DATA_FORGE_MODULE,
+});