eslint-plugin-ts-data-forge 0.8.5 → 0.9.0

package/src/rules/prefer-canonical-array-slicing.test.mts

@@ -675,6 +675,61 @@ describe('prefer-canonical-array-slicing through type wrappers', () => {
           { messageId: 'preferCanonicalArraySlicing' },
         ],
       },
+      {
+        name: 'a filter callback whose body is wrapped',
+        code: dedent`
+          declare const xs: readonly number[];
+          const ys = xs.filter((_, i) => (i >= 1) satisfies boolean);
+        `,
+        output: dedent`
+          import { Arr } from 'ts-data-forge';
+          declare const xs: readonly number[];
+          const ys = Arr.tail(xs);
+        `,
+        errors: [{ messageId: 'preferCanonicalArraySlicing' }],
+      },
+      {
+        name: 'a wrapped `xs.length - N`, and a wrapped `.length` or receiver inside it',
+        code: dedent`
+          declare const xs: readonly number[];
+          const a = xs.slice(0, (xs.length - 1) as number);
+          const b = xs.slice(0, (xs as readonly number[]).length - 1);
+          const c = xs.filter((_, i) => i < (xs.length satisfies number) - 2);
+          const d = xs.toSpliced(0, xs!.length - 2);
+        `,
+        output: dedent`
+          import { Arr } from 'ts-data-forge';
+          declare const xs: readonly number[];
+          const a = Arr.butLast(xs);
+          const b = Arr.butLast(xs);
+          const c = Arr.skipLast(xs, 2);
+          const d = Arr.takeLast(xs, 2);
+        `,
+        errors: [
+          { messageId: 'preferCanonicalArraySlicing' },
+          { messageId: 'preferCanonicalArraySlicing' },
+          { messageId: 'preferCanonicalArraySlicing' },
+          { messageId: 'preferCanonicalArraySlicing' },
+        ],
+      },
+      {
+        name: 'a wrapped receiver compared with its own `.length`',
+        code: dedent`
+          declare const xs: readonly number[];
+          const a = (xs satisfies readonly number[]).slice(0, xs.length - 1);
+          const b = xs.toSpliced((xs.length as number), 0, 1);
+        `,
+        output: dedent`
+          import { Arr } from 'ts-data-forge';
+          declare const xs: readonly number[];
+          const a = Arr.butLast(xs satisfies readonly number[]);
+          const b = Arr.toPushed(xs, 1);
+        `,
+        errors: [
+          { messageId: 'preferCanonicalArraySlicing' },
+          { messageId: 'preferCanonicalArraySlicing' },
+        ],
+      },
     ],
   });
 });

package/src/rules/prefer-canonical-length-cast.mts

@@ -4,8 +4,12 @@ import {
   type TSESLint,
   type TSESTree,
 } from '@typescript-eslint/utils';
-import { skipTypeWrappers } from './ast-utils.mjs';
-import { getImportedLocalName, getTsDataForgeImport } from './import-utils.mjs';
+import {
+  getImportDeclarations,
+  getImportedLocalName,
+  skipTypeWrappers,
+} from 'eslint-rule-forge';
+import { TS_DATA_FORGE_MODULE } from './constants.mjs';
 
 type Options = readonly [];
 
@@ -143,7 +147,7 @@ export const preferCanonicalLengthCast: TSESLint.RuleModule<
     const sourceCode = context.sourceCode;
 
     const arrLocalName = getImportedLocalName(
-      getTsDataForgeImport(sourceCode.ast),
+      getImportDeclarations(sourceCode.ast, TS_DATA_FORGE_MODULE),
       'Arr',
     );
 

package/src/rules/prefer-canonical-length-guard.mts

@@ -3,9 +3,14 @@ import {
   type TSESLint,
   type TSESTree,
 } from '@typescript-eslint/utils';
+import {
+  getArgumentText,
+  getImportDeclarations,
+  getImportedLocalName,
+  skipTypeWrappers,
+} from 'eslint-rule-forge';
 import type { MutableRecord, ReadonlyRecord } from 'ts-type-forge';
-import { skipTypeWrappers, toArgumentText } from './ast-utils.mjs';
-import { getImportedLocalName, getTsDataForgeImport } from './import-utils.mjs';
+import { TS_DATA_FORGE_MODULE } from './constants.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';
@@ -117,7 +122,7 @@ export const preferCanonicalLengthGuard: TSESLint.RuleModule<
     const sourceCode = context.sourceCode;
 
     const arrLocalName = getImportedLocalName(
-      getTsDataForgeImport(sourceCode.ast),
+      getImportDeclarations(sourceCode.ast, TS_DATA_FORGE_MODULE),
       'Arr',
     );
 
@@ -154,7 +159,7 @@ export const preferCanonicalLengthGuard: TSESLint.RuleModule<
             return;
           }
 
-          const arrayText = toArgumentText(array, sourceCode);
+          const arrayText = getArgumentText(sourceCode, array);
 
           context.report({
             node,

package/src/rules/prefer-comparison-over-nullish-guard.mts

@@ -3,8 +3,9 @@ import {
   type TSESLint,
   type TSESTree,
 } from '@typescript-eslint/utils';
+import { buildCalleeResolver, getImportDeclarations } from 'eslint-rule-forge';
 import type { DeepReadonly, ReadonlyRecord } from 'ts-type-forge';
-import { buildCalleeResolver, getTsDataForgeImport } from './import-utils.mjs';
+import { TS_DATA_FORGE_MODULE } from './constants.mjs';
 
 type Options = readonly [];
 
@@ -121,7 +122,7 @@ export const preferComparisonOverNullishGuard: TSESLint.RuleModule<
     const sourceCode = context.sourceCode;
 
     const resolveGuard = buildCalleeResolver(
-      getTsDataForgeImport(sourceCode.ast),
+      getImportDeclarations(sourceCode.ast, TS_DATA_FORGE_MODULE),
     );
 
     return {

package/src/rules/prefer-comparison-over-nullish-guard.test.mts

@@ -49,6 +49,22 @@ describe('prefer-comparison-over-nullish-guard', () => {
         },
       ],
       invalid: [
+        {
+          name: 'the guard imported by a second ts-data-forge declaration',
+          code: dedent`
+            import type { Optional } from 'ts-data-forge';
+            import { isUndefined } from 'ts-data-forge';
+            declare const x: string | undefined;
+            const y = isUndefined(x);
+          `,
+          output: dedent`
+            import type { Optional } from 'ts-data-forge';
+            import { isUndefined } from 'ts-data-forge';
+            declare const x: string | undefined;
+            const y = x === undefined;
+          `,
+          errors: [{ messageId: 'preferComparison' }],
+        },
         {
           name: 'isNotUndefined with explicit argument',
           code: dedent`

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

@@ -3,12 +3,15 @@ import {
   type TSESLint,
   type TSESTree,
 } from '@typescript-eslint/utils';
-import { skipTypeWrappers } from './ast-utils.mjs';
 import {
-  buildImportFixes,
+  buildNamedImportFix,
+  getImportDeclarations,
   getNamedImports,
-  getTsDataForgeImport,
-} from './import-utils.mjs';
+  getRangeWithParens,
+  parenthesesDepth,
+  skipTypeWrappers,
+} from 'eslint-rule-forge';
+import { TS_DATA_FORGE_MODULE } from './constants.mjs';
 
 type Options = readonly [];
 
@@ -19,7 +22,7 @@ export const preferIsNonNullObject: TSESLint.RuleModule<MessageIds, Options> = {
     type: 'suggestion',
     docs: {
       description:
-        'Replace `typeof u === "object" && u !== null` with `isNonNullObject(u)` from ts-data-forge.',
+        'Replace `typeof u === "object" && u !== null`, in either order and anywhere in an `&&` chain, with `isNonNullObject(u)` from ts-data-forge.',
     },
     fixable: 'code',
     schema: [],
@@ -34,51 +37,55 @@ export const preferIsNonNullObject: TSESLint.RuleModule<MessageIds, Options> = {
 
     const program = sourceCode.ast;
 
-    const tsDataForgeImport = getTsDataForgeImport(program);
+    const tsDataForgeImports = getImportDeclarations(
+      program,
+      TS_DATA_FORGE_MODULE,
+    );
 
-    const mut_nodesToFix: {
-      node: TSESTree.LogicalExpression;
-      identifierName: string;
-    }[] = [];
+    const mut_pairsToFix: NonNullObjectPair[] = [];
 
     return {
       LogicalExpression: (node) => {
-        const identifierName = getNonNullObjectIdentifierName(node);
-
-        if (identifierName === undefined) {
+        // A chain is read once, from its outermost `&&`.
+        if (node.operator !== '&&' || isChainOperand(sourceCode, node)) {
           return;
         }
 
-        mut_nodesToFix.push({ node, identifierName });
+        mut_pairsToFix.push(...findNonNullObjectPairs(sourceCode, node));
       },
       'Program:exit': () => {
-        // Check if isNonNullObject is already imported
         const hasIsNonNullObjectImport =
-          getNamedImports(tsDataForgeImport).includes('isNonNullObject');
+          getNamedImports(tsDataForgeImports).includes('isNonNullObject');
 
-        // 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.
+        // 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, identifierName },
-        ] of mut_nodesToFix.entries()) {
+          { range, identifierName },
+        ] of mut_pairsToFix.entries()) {
           context.report({
-            node,
+            loc: {
+              start: sourceCode.getLocFromIndex(range[0]),
+              end: sourceCode.getLocFromIndex(range[1]),
+            },
             messageId: 'useIsNonNullObject',
             fix: (fixer) => {
               const replacement = `isNonNullObject(${identifierName})`;
 
-              // Add import only for the first node and only if not already imported
               const importFixes =
                 index === 0 && !hasIsNonNullObjectImport
-                  ? buildImportFixes(fixer, program, tsDataForgeImport, [
+                  ? buildNamedImportFix(fixer, program, TS_DATA_FORGE_MODULE, [
                       'isNonNullObject',
                     ])
                   : [];
 
-              return [...importFixes, fixer.replaceText(node, replacement)];
+              return [
+                ...importFixes,
+                fixer.replaceTextRange(range, replacement),
+              ];
             },
           });
         }
@@ -89,39 +96,123 @@ export const preferIsNonNullObject: TSESLint.RuleModule<MessageIds, Options> = {
 } as const;
 
 /**
- * The name of the value checked by `typeof u === 'object' && u !== null`, or
- * `undefined`. Every operand is read through type wrappers:
- * `(u satisfies unknown) !== null` and `u! !== null` check the same `u`.
+ * 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`.
  */
-const getNonNullObjectIdentifierName = (
-  // AST nodes hold mutable child arrays, so they are not deeply readonly.
+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,
-): string | undefined => {
-  if (node.operator !== '&&') {
-    return undefined;
-  }
+): boolean =>
+  node.parent.type === AST_NODE_TYPES.LogicalExpression &&
+  node.parent.operator === '&&' &&
+  parenthesesDepth(sourceCode, node) === 0;
 
-  const leftIdentifierName = getTypeofObjectIdentifierName(node.left);
+/**
+ * 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];
 
-  const rightIdentifierName = getNonNullCheckIdentifierName(node.right);
+    if (first === undefined || second === undefined) {
+      return [];
+    }
 
-  return leftIdentifierName === undefined ||
-    rightIdentifierName === undefined ||
-    leftIdentifierName !== rightIdentifierName
-    ? undefined
-    : leftIdentifierName;
+    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);
 };
 
-const getTypeofObjectIdentifierName = (
+/**
+ * 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
-  node: TSESTree.Expression,
+  nullCheck: TSESTree.Expression,
 ): string | undefined => {
-  if (node.type !== AST_NODE_TYPES.BinaryExpression) {
-    return undefined;
-  }
+  const identifierName = getTypeofObjectIdentifierName(
+    skipTypeWrappers(typeofCheck),
+  );
 
-  if (node.operator !== '===') {
+  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;
   }
 
@@ -129,31 +220,39 @@ const getTypeofObjectIdentifierName = (
 
   const right = skipTypeWrappers(node.right);
 
+  const typeofSide = isLiteralOf(right, 'object')
+    ? left
+    : isLiteralOf(left, 'object')
+      ? right
+      : undefined;
+
   if (
-    left.type !== AST_NODE_TYPES.UnaryExpression ||
-    left.operator !== 'typeof' ||
-    right.type !== AST_NODE_TYPES.Literal ||
-    right.value !== 'object'
+    typeofSide?.type !== AST_NODE_TYPES.UnaryExpression ||
+    typeofSide.operator !== 'typeof'
   ) {
     return undefined;
   }
 
-  const argument = skipTypeWrappers(left.argument);
+  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.Expression,
+  node: TSESTree.Node,
 ): string | undefined => {
-  if (node.type !== AST_NODE_TYPES.BinaryExpression) {
-    return undefined;
-  }
-
-  if (node.operator !== '!==') {
+  if (
+    node.type !== AST_NODE_TYPES.BinaryExpression ||
+    (node.operator !== '!==' && node.operator !== '!=')
+  ) {
     return undefined;
   }
 
@@ -161,9 +260,17 @@ const getNonNullCheckIdentifierName = (
 
   const right = skipTypeWrappers(node.right);
 
-  return left.type !== AST_NODE_TYPES.Identifier ||
-    right.type !== AST_NODE_TYPES.Literal ||
-    right.value !== null
-    ? undefined
-    : left.name;
+  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;

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

@@ -193,6 +193,144 @@ describe('prefer-is-non-null-object through type wrappers', () => {
           { messageId: 'useIsNonNullObject' },
         ],
       },
+      {
+        name: 'both halves wrapped as a whole',
+        code: dedent`
+          import { isNonNullObject } from 'ts-data-forge';
+          declare const u: unknown;
+          const ok =
+            ((typeof u === 'object') satisfies boolean) &&
+            ((u !== null) as boolean);
+        `,
+        output: dedent`
+          import { isNonNullObject } from 'ts-data-forge';
+          declare const u: unknown;
+          const ok =
+            isNonNullObject(u);
+        `,
+        errors: [{ messageId: 'useIsNonNullObject' }],
+      },
     ],
   });
 }, 20000);
+
+describe('prefer-is-non-null-object in other forms', () => {
+  tester.run('prefer-is-non-null-object', preferIsNonNullObject, {
+    valid: [
+      {
+        name: 'the two halves joined by `||`',
+        code: dedent`
+          declare const u: unknown;
+          const ok = typeof u === 'object' || u !== null;
+        `,
+      },
+      {
+        name: 'the two halves not next to each other in the chain',
+        code: dedent`
+          declare const u: unknown;
+          declare const a: boolean;
+          const ok = typeof u === 'object' && a && u !== null;
+        `,
+      },
+      {
+        name: 'an undefined check is not a null check',
+        code: dedent`
+          declare const u: unknown;
+          const ok = u !== undefined && typeof u === 'object';
+        `,
+      },
+      {
+        name: 'the halves split by parentheses',
+        code: dedent`
+          declare const u: unknown;
+          declare const b: boolean;
+          const ok = typeof u === 'object' && (u !== null && b);
+        `,
+      },
+    ],
+    invalid: [
+      {
+        name: 'the halves in reverse order',
+        code: dedent`
+          declare const u: unknown;
+          const ok = u !== null && typeof u === 'object';
+        `,
+        output: dedent`
+          import { isNonNullObject } from 'ts-data-forge';
+          declare const u: unknown;
+          const ok = isNonNullObject(u);
+        `,
+        errors: [{ messageId: 'useIsNonNullObject' }],
+      },
+      {
+        name: 'each comparison with its operands swapped',
+        code: dedent`
+          declare const u: unknown;
+          const ok = 'object' === typeof u && null !== u;
+        `,
+        output: dedent`
+          import { isNonNullObject } from 'ts-data-forge';
+          declare const u: unknown;
+          const ok = isNonNullObject(u);
+        `,
+        errors: [{ messageId: 'useIsNonNullObject' }],
+      },
+      {
+        name: '`!= null`, which typeof has already made the same check',
+        code: dedent`
+          declare const u: unknown;
+          const ok = typeof u === 'object' && u != null;
+        `,
+        output: dedent`
+          import { isNonNullObject } from 'ts-data-forge';
+          declare const u: unknown;
+          const ok = isNonNullObject(u);
+        `,
+        errors: [{ messageId: 'useIsNonNullObject' }],
+      },
+      {
+        name: 'the pair at the start, the end and the middle of a longer chain',
+        code: dedent`
+          declare const u: unknown;
+          declare const a: boolean;
+          declare const b: boolean;
+          const x = typeof u === 'object' && u !== null && 'k' in u;
+          const y = a && typeof u === 'object' && u !== null;
+          const z = a && u !== null && (typeof u === 'object') && b;
+        `,
+        output: dedent`
+          import { isNonNullObject } from 'ts-data-forge';
+          declare const u: unknown;
+          declare const a: boolean;
+          declare const b: boolean;
+          const x = isNonNullObject(u) && 'k' in u;
+          const y = a && isNonNullObject(u);
+          const z = a && isNonNullObject(u) && b;
+        `,
+        errors: [
+          { messageId: 'useIsNonNullObject' },
+          { messageId: 'useIsNonNullObject' },
+          { messageId: 'useIsNonNullObject' },
+        ],
+      },
+      {
+        name: 'two pairs in one chain',
+        code: dedent`
+          declare const u: unknown;
+          declare const v: unknown;
+          const ok = typeof u === 'object' && u !== null && v !== null && typeof v === 'object';
+        `,
+        output: dedent`
+          import { isNonNullObject } from 'ts-data-forge';
+          declare const u: unknown;
+          declare const v: unknown;
+          const ok = isNonNullObject(u) && isNonNullObject(v);
+        `,
+        errors: [
+          { messageId: 'useIsNonNullObject' },
+          { messageId: 'useIsNonNullObject' },
+        ],
+      },
+    ],
+  });
+});