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

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

@@ -188,6 +188,25 @@ describe('prefer-arr-is-bounded-length-array through type wrappers', () => {
             { messageId: 'useIsBoundedLengthArray' },
           ],
         },
+        {
+          name: 'either comparison wrapped as a whole',
+          code: dedent`
+            import { Arr } from 'ts-data-forge';
+            declare const xs: readonly number[];
+            const a = (xs.length >= 1 satisfies boolean) && xs.length <= 3;
+            const b = xs.length >= 1 && (xs.length <= 3 as boolean);
+          `,
+          output: dedent`
+            import { Arr } from 'ts-data-forge';
+            declare const xs: readonly number[];
+            const a = Arr.isBoundedLengthArray(1, 3, xs);
+            const b = Arr.isBoundedLengthArray(1, 3, xs);
+          `,
+          errors: [
+            { messageId: 'useIsBoundedLengthArray' },
+            { messageId: 'useIsBoundedLengthArray' },
+          ],
+        },
       ],
     },
   );

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

@@ -205,6 +205,14 @@ describe('prefer-arr-is-max-length-array through type wrappers', () => {
           const ok = xs!.length >= 1 && xs.length <= 3;
         `,
       },
+      {
+        name: 'one half of a bounded pair, either half wrapped as a whole',
+        code: dedent`
+          declare const xs: readonly number[];
+          const a = (xs.length >= 1 satisfies boolean) && xs.length <= 3;
+          const b = xs.length >= 1 && (xs.length <= 3 as boolean);
+        `,
+      },
     ],
     invalid: [
       {

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

@@ -219,6 +219,14 @@ describe('prefer-arr-is-min-length-array through type wrappers', () => {
           const ok = xs.length >= 1 && (xs as readonly number[]).length <= 3;
         `,
       },
+      {
+        name: 'one half of a bounded pair, either half wrapped as a whole',
+        code: dedent`
+          declare const xs: readonly number[];
+          const a = (xs.length >= 1 satisfies boolean) && xs.length <= 3;
+          const b = xs.length >= 1 && (xs.length <= 3 as boolean);
+        `,
+      },
     ],
     invalid: [
       {

package/src/rules/prefer-arr-uniq.mts

@@ -14,7 +14,8 @@ import {
 } from 'eslint-rule-forge';
 import { Arr } from 'ts-data-forge';
 import * as ts from 'typescript';
-import { TS_DATA_FORGE_MODULE } from './constants.mjs';
+import { primitiveTypeFlags, TS_DATA_FORGE_MODULE } from './constants.mjs';
+import { needsMutableResult } from './mutable-result.mjs';
 
 type Options = readonly [];
 
@@ -215,19 +216,6 @@ export const preferArrUniq: TSESLint.RuleModule<MessageIds, Options> = {
   defaultOptions: [],
 } as const;
 
-/** Methods that `ReadonlyArray` lacks and that mutate the receiver. */
-const mutatingMethods: ReadonlySet<string> = new Set([
-  'copyWithin',
-  'fill',
-  'pop',
-  'push',
-  'reverse',
-  'shift',
-  'sort',
-  'splice',
-  'unshift',
-]);
-
 /**
  * Returns `xs` for `new Set(xs)`, and `undefined` for anything else — including
  * `new Set()`, `new Set<T>(xs)` (whose element type may be wider than `xs`'s)
@@ -317,15 +305,6 @@ const isPrimitiveType = (
     : (resolved.flags & primitiveTypeFlags) !== 0;
 };
 
-const primitiveTypeFlags =
-  ts.TypeFlags.StringLike |
-  ts.TypeFlags.NumberLike |
-  ts.TypeFlags.BigIntLike |
-  ts.TypeFlags.BooleanLike |
-  ts.TypeFlags.ESSymbolLike |
-  ts.TypeFlags.Null |
-  ts.TypeFlags.Undefined;
-
 const resolveConstraint = (
   // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
   checker: ts.TypeChecker,
@@ -335,187 +314,3 @@ const resolveConstraint = (
   (type.flags & ts.TypeFlags.TypeParameter) !== 0
     ? (checker.getBaseConstraintOfType(type) ?? type)
     : type;
-
-/**
- * Whether the code around `node` visibly relies on the result being a mutable
- * array, so that swapping in the readonly array `Arr.uniq` returns would not
- * compile. Looks at `node` itself and, when it initializes a variable without a
- * type annotation, at every read of that variable.
- */
-const needsMutableResult = (
-  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-  sourceCode: TSESLint.SourceCode,
-  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-  checker: ts.TypeChecker,
-  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-  getTsNode: (esNode: TSESTree.Node) => ts.Node | undefined,
-  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-  node: TSESTree.Node,
-): boolean => {
-  const outer = outermostTypePreservingWrapper(node);
-
-  if (isUsedAsMutable(checker, getTsNode, outer)) {
-    return true;
-  }
-
-  const parent = outer.parent;
-
-  if (
-    parent?.type !== AST_NODE_TYPES.VariableDeclarator ||
-    parent.init !== outer ||
-    parent.id.type !== AST_NODE_TYPES.Identifier ||
-    parent.id.typeAnnotation !== undefined
-  ) {
-    return false;
-  }
-
-  const [variable] = sourceCode.getDeclaredVariables(parent);
-
-  return (
-    variable?.references.some(
-      (reference) =>
-        reference.init !== true &&
-        isUsedAsMutable(
-          checker,
-          getTsNode,
-          outermostTypePreservingWrapper(reference.identifier),
-        ),
-    ) ?? false
-  );
-};
-
-/**
- * `node`, or the outermost `!` / `satisfies` around it. Neither changes the
- * type the value is used at, so `Array.from(new Set(xs))!.push(4)` and
- * `ys!.push(4)` still need a mutable array. An `as` does change it, and a
- * readonly array may be cast to a mutable one, so the walk stops there.
- */
-const outermostTypePreservingWrapper = (
-  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-  node: TSESTree.Node,
-): TSESTree.Node => {
-  const { parent } = node;
-
-  return parent !== undefined &&
-    (parent.type === AST_NODE_TYPES.TSNonNullExpression ||
-      parent.type === AST_NODE_TYPES.TSSatisfiesExpression) &&
-    parent.expression === node
-    ? outermostTypePreservingWrapper(parent)
-    : node;
-};
-
-const isUsedAsMutable = (
-  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-  checker: ts.TypeChecker,
-  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-  getTsNode: (esNode: TSESTree.Node) => ts.Node | undefined,
-  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-  node: TSESTree.Node,
-): boolean => {
-  const parent = node.parent;
-
-  if (
-    parent?.type === AST_NODE_TYPES.MemberExpression &&
-    parent.object === node
-  ) {
-    // xs.push(...), xs.sort(), ...
-    if (
-      !parent.computed &&
-      parent.property.type === AST_NODE_TYPES.Identifier &&
-      mutatingMethods.has(parent.property.name)
-    ) {
-      return true;
-    }
-
-    // xs[0] = ..., xs.length = ..., xs[0]++, delete xs[0]
-    const grandParent = parent.parent;
-
-    return (
-      (grandParent.type === AST_NODE_TYPES.AssignmentExpression &&
-        grandParent.left === parent) ||
-      grandParent.type === AST_NODE_TYPES.UpdateExpression ||
-      (grandParent.type === AST_NODE_TYPES.UnaryExpression &&
-        grandParent.operator === 'delete')
-    );
-  }
-
-  // Passed to a parameter, assigned to a variable, or returned from a function
-  // whose declared type is a mutable array.
-  const tsNode = getTsNode(node);
-
-  if (tsNode === undefined) {
-    return false;
-  }
-
-  if (!ts.isExpression(tsNode)) {
-    return false;
-  }
-
-  const expectedType =
-    getDeclaredParameterType(checker, tsNode) ??
-    checker.getContextualType(tsNode);
-
-  return (
-    expectedType !== undefined && isMutableArrayOnly(checker, expectedType)
-  );
-};
-
-/**
- * The declared type of the parameter `argument` is passed to. The contextual
- * type of an argument to a generic function is instantiated from that very
- * argument — `Arr.toSorted(Array.from(set), cmp)` has `Ar` inferred as
- * `string[]` — so it would read as "a mutable array is required" for any
- * generic parameter. The declared type (`Ar extends readonly unknown[]`) is
- * what the rewritten argument actually has to satisfy.
- */
-const getDeclaredParameterType = (
-  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-  checker: ts.TypeChecker,
-  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-  argument: ts.Expression,
-): ts.Type | undefined => {
-  const call = argument.parent;
-
-  if (!ts.isCallExpression(call) && !ts.isNewExpression(call)) {
-    return undefined;
-  }
-
-  const index = call.arguments?.indexOf(argument) ?? -1;
-
-  if (index === -1) {
-    return undefined;
-  }
-
-  const declaration = checker.getResolvedSignature(call)?.getDeclaration();
-
-  const parameter = declaration?.parameters[index];
-
-  // A rest parameter's declared type is the array of arguments, not the type of
-  // one; the contextual type is the better answer there.
-  return parameter === undefined || parameter.dotDotDotToken !== undefined
-    ? undefined
-    : checker.getTypeAtLocation(parameter);
-};
-
-/**
- * Whether a readonly array cannot be assigned to `type`: it is a mutable array,
- * or a union of mutable arrays and primitives. (A tuple accepted no array to
- * begin with, so it does not matter here.)
- */
-const isMutableArrayOnly = (
-  // 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 => {
-  const members = type.isUnion() ? type.types : ([type] as const);
-
-  return (
-    members.every(
-      (t) =>
-        // `null`, `undefined` and other primitives accept no array at all.
-        (t.flags & primitiveTypeFlags) !== 0 ||
-        (checker.isArrayType(t) && t.getSymbol()?.getName() === 'Array'),
-    ) && members.some((t) => (t.flags & primitiveTypeFlags) === 0)
-  );
-};

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

@@ -84,23 +84,32 @@ const asNegatedPositiveIntegerLiteral = (
 
 /**
  * Whether re-reading the expression is free of side effects (a plain variable
- * or a non-computed property chain). Required for patterns that reference the
- * receiver twice, such as `xs.filter((_, i) => i < xs.length - 1)`.
+ * or a non-computed property chain, type wrappers aside). Required for
+ * patterns that reference the receiver twice, such as
+ * `xs.filter((_, i) => i < xs.length - 1)`.
  */
-const isSimpleReference = (node: TSESTree.Node): boolean =>
-  node.type === AST_NODE_TYPES.Identifier ||
-  node.type === AST_NODE_TYPES.ThisExpression ||
-  (node.type === AST_NODE_TYPES.MemberExpression &&
-    !node.computed &&
-    node.property.type === AST_NODE_TYPES.Identifier &&
-    isSimpleReference(node.object));
-
-const rootIdentifierName = (node: TSESTree.Node): string | undefined =>
-  node.type === AST_NODE_TYPES.Identifier
+const isSimpleReference = (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 &&
+      node.property.type === AST_NODE_TYPES.Identifier &&
+      isSimpleReference(node.object))
+  );
+};
+
+const rootIdentifierName = (wrapped: TSESTree.Node): string | undefined => {
+  const node = skipTypeWrappers(wrapped);
+
+  return node.type === AST_NODE_TYPES.Identifier
     ? node.name
     : node.type === AST_NODE_TYPES.MemberExpression
       ? rootIdentifierName(node.object)
       : undefined;
+};
 
 type ComparisonOperator = '!==' | '<' | '<=' | '>' | '>=';
 
@@ -338,26 +347,41 @@ export const preferCanonicalArraySlicing: TSESLint.RuleModule<
       });
     };
 
-    /** Matches `<xsText>.length` (non-computed). */
+    /**
+     * Matches `<receiver>.length` (non-computed), type wrappers aside on the
+     * access, on its object and on the receiver:
+     * `(xs as readonly T[]).length` reads the length of `xs`.
+     */
     const isReceiverLengthAccess = (
-      node: TSESTree.Node,
-      receiverText: string,
-    ): boolean =>
-      node.type === AST_NODE_TYPES.MemberExpression &&
-      !node.computed &&
-      node.property.type === AST_NODE_TYPES.Identifier &&
-      node.property.name === 'length' &&
-      sourceCode.getText(node.object) === receiverText;
+      wrapped: TSESTree.Node,
+      receiver: TSESTree.Expression,
+    ): boolean => {
+      const node = skipTypeWrappers(wrapped);
+
+      return (
+        node.type === AST_NODE_TYPES.MemberExpression &&
+        !node.computed &&
+        node.property.type === AST_NODE_TYPES.Identifier &&
+        node.property.name === 'length' &&
+        sourceCode.getText(skipTypeWrappers(node.object)) ===
+          sourceCode.getText(skipTypeWrappers(receiver))
+      );
+    };
 
-    /** Matches `<xsText>.length - M` (M ≥ 1) and returns `M`. */
+    /**
+     * Matches `<receiver>.length - M` (M ≥ 1), under any type wrapper, and
+     * returns `M`.
+     */
     const matchLengthMinus = (
-      node: TSESTree.Node,
-      receiverText: string,
+      wrapped: TSESTree.Node,
+      receiver: TSESTree.Expression,
     ): number | undefined => {
+      const node = skipTypeWrappers(wrapped);
+
       if (
         node.type !== AST_NODE_TYPES.BinaryExpression ||
         node.operator !== '-' ||
-        !isReceiverLengthAccess(node.left, receiverText)
+        !isReceiverLengthAccess(node.left, receiver)
       ) {
         return undefined;
       }
@@ -375,7 +399,6 @@ export const preferCanonicalArraySlicing: TSESLint.RuleModule<
     const classifyFilterCallback = (
       callback: TSESTree.CallExpressionArgument,
       receiver: TSESTree.Expression,
-      receiverText: string,
     ): CopyOp | undefined => {
       if (
         callback.type !== AST_NODE_TYPES.ArrowFunctionExpression ||
@@ -409,7 +432,8 @@ export const preferCanonicalArraySlicing: TSESLint.RuleModule<
         return undefined;
       }
 
-      const body = callback.body;
+      // `(i >= 1) satisfies boolean` is still the comparison.
+      const body = skipTypeWrappers(callback.body);
 
       if (
         body.type !== AST_NODE_TYPES.BinaryExpression ||
@@ -456,7 +480,7 @@ export const preferCanonicalArraySlicing: TSESLint.RuleModule<
         return undefined;
       }
 
-      const m = matchLengthMinus(other, receiverText);
+      const m = matchLengthMinus(other, receiver);
 
       return m === undefined ? undefined : classifyLengthComparison(op, m);
     };
@@ -512,7 +536,7 @@ export const preferCanonicalArraySlicing: TSESLint.RuleModule<
           return undefined;
         }
 
-        const m = matchLengthMinus(end, sourceCode.getText(receiver));
+        const m = matchLengthMinus(end, receiver);
 
         return m === undefined ? undefined : normalizeCountedOp('skipLast', m);
       }
@@ -523,7 +547,6 @@ export const preferCanonicalArraySlicing: TSESLint.RuleModule<
     const classifyToSplicedArgs = (
       args: readonly TSESTree.CallExpressionArgument[],
       receiver: TSESTree.Expression,
-      receiverText: string,
     ): CopyOp | undefined => {
       if (args.length === 1) {
         const [start] = args;
@@ -572,7 +595,7 @@ export const preferCanonicalArraySlicing: TSESLint.RuleModule<
           return undefined;
         }
 
-        const m = matchLengthMinus(deleteCount, receiverText);
+        const m = matchLengthMinus(deleteCount, receiver);
 
         return m === undefined ? undefined : normalizeCountedOp('takeLast', m);
       }
@@ -598,7 +621,7 @@ export const preferCanonicalArraySlicing: TSESLint.RuleModule<
         // `xs.toSpliced(xs.length, 0, item)` appends → toPushed.
         if (
           isSimpleReference(receiver) &&
-          isReceiverLengthAccess(start, receiverText)
+          isReceiverLengthAccess(start, receiver)
         ) {
           return { fn: 'toPushed', itemText: toArgText(item) };
         }
@@ -702,8 +725,6 @@ export const preferCanonicalArraySlicing: TSESLint.RuleModule<
           return;
         }
 
-        const receiverText = sourceCode.getText(receiver);
-
         switch (methodName) {
           case 'slice': {
             const op = classifySliceArgs(node.arguments, receiver);
@@ -716,11 +737,7 @@ export const preferCanonicalArraySlicing: TSESLint.RuleModule<
           }
 
           case 'toSpliced': {
-            const op = classifyToSplicedArgs(
-              node.arguments,
-              receiver,
-              receiverText,
-            );
+            const op = classifyToSplicedArgs(node.arguments, receiver);
 
             if (op !== undefined) {
               report(node, op, toArgText(receiver));
@@ -736,7 +753,7 @@ export const preferCanonicalArraySlicing: TSESLint.RuleModule<
               return;
             }
 
-            const op = classifyFilterCallback(callback, receiver, receiverText);
+            const op = classifyFilterCallback(callback, receiver);
 
             if (op !== undefined) {
               report(node, op, toArgText(receiver));

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' },
+        ],
+      },
     ],
   });
 });