eslint-plugin-ts-data-forge 0.8.1 → 0.8.3

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

@@ -5,6 +5,7 @@ import {
 } from '@typescript-eslint/utils';
 import { Arr } from 'ts-data-forge';
 import * as ts from 'typescript';
+import { skipTypeWrappers, typeWrapperLayers } from './ast-utils.mjs';
 import {
   buildImportFixes,
   getImportedLocalName,
@@ -79,18 +80,29 @@ export const preferArrUniq: TSESLint.RuleModule<MessageIds, Options> = {
     ): void => {
       const arrayExpression = getSetSourceArray(setNode);
 
-      if (arrayExpression === undefined) return;
+      if (arrayExpression === undefined) {
+        return;
+      }
 
-      if (!isGlobal(sourceCode, node, 'Set')) return;
+      if (!isGlobal(sourceCode, node, 'Set')) {
+        return;
+      }
 
-      const arrayTsNode = getTsNode(arrayExpression);
+      // At every layer of type wrappers (see typeWrapperLayers).
+      const isPrimitiveArray = typeWrapperLayers(arrayExpression).every(
+        (layer) => {
+          const tsNode = getTsNode(layer);
 
-      if (arrayTsNode === undefined) return;
+          return (
+            tsNode !== undefined &&
+            isPrimitiveArrayType(checker, checker.getTypeAtLocation(tsNode))
+          );
+        },
+      );
 
-      if (
-        !isPrimitiveArrayType(checker, checker.getTypeAtLocation(arrayTsNode))
-      )
+      if (!isPrimitiveArray) {
         return;
+      }
 
       mut_matches.push({
         node,
@@ -117,17 +129,23 @@ export const preferArrUniq: TSESLint.RuleModule<MessageIds, Options> = {
           return;
         }
 
-        if (!isGlobal(sourceCode, node, 'Array')) return;
+        if (!isGlobal(sourceCode, node, 'Array')) {
+          return;
+        }
 
         check(node, node.arguments[0]);
       },
       ArrayExpression: (node) => {
         // [...new Set(xs)]
-        if (!Arr.isFixedLengthTuple(1, node.elements)) return;
+        if (!Arr.isFixedLengthTuple(1, node.elements)) {
+          return;
+        }
 
         const element = node.elements[0];
 
-        if (element?.type !== AST_NODE_TYPES.SpreadElement) return;
+        if (element?.type !== AST_NODE_TYPES.SpreadElement) {
+          return;
+        }
 
         check(node, element.argument);
       },
@@ -208,8 +226,11 @@ const mutatingMethods: ReadonlySet<string> = new Set([
  */
 const getSetSourceArray = (
   // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-  node: TSESTree.Node,
+  wrapped: TSESTree.Node,
 ): TSESTree.Expression | undefined => {
+  // `new Set(xs) as ReadonlySet<string>` is still `new Set(xs)`.
+  const node = skipTypeWrappers(wrapped);
+
   if (
     node.type !== AST_NODE_TYPES.NewExpression ||
     node.callee.type !== AST_NODE_TYPES.Identifier ||
@@ -246,11 +267,10 @@ const findVariable = (
 ): TSESLint.Scope.Variable | undefined => {
   const variable = scope.set.get(name);
 
-  if (variable !== undefined) return variable;
-
-  if (scope.upper === null) return undefined;
-
-  return findVariable(scope.upper, name);
+  return (
+    variable ??
+    (scope.upper === null ? undefined : findVariable(scope.upper, name))
+  );
 };
 
 /**
@@ -296,11 +316,9 @@ const isPrimitiveType = (
 ): boolean => {
   const resolved = resolveConstraint(checker, type);
 
-  if (resolved.isUnion()) {
-    return resolved.types.every((t) => isPrimitiveType(checker, t));
-  }
-
-  return (resolved.flags & primitiveTypeFlags) !== 0;
+  return resolved.isUnion()
+    ? resolved.types.every((t) => isPrimitiveType(checker, t))
+    : (resolved.flags & primitiveTypeFlags) !== 0;
 };
 
 const primitiveTypeFlags =
@@ -338,13 +356,17 @@ const needsMutableResult = (
   // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
   node: TSESTree.Node,
 ): boolean => {
-  if (isUsedAsMutable(checker, getTsNode, node)) return true;
+  const outer = outermostTypePreservingWrapper(node);
 
-  const parent = node.parent;
+  if (isUsedAsMutable(checker, getTsNode, outer)) {
+    return true;
+  }
+
+  const parent = outer.parent;
 
   if (
     parent?.type !== AST_NODE_TYPES.VariableDeclarator ||
-    parent.init !== node ||
+    parent.init !== outer ||
     parent.id.type !== AST_NODE_TYPES.Identifier ||
     parent.id.typeAnnotation !== undefined
   ) {
@@ -357,11 +379,35 @@ const needsMutableResult = (
     variable?.references.some(
       (reference) =>
         reference.init !== true &&
-        isUsedAsMutable(checker, getTsNode, reference.identifier),
+        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,
@@ -401,9 +447,13 @@ const isUsedAsMutable = (
   // whose declared type is a mutable array.
   const tsNode = getTsNode(node);
 
-  if (tsNode === undefined) return false;
+  if (tsNode === undefined) {
+    return false;
+  }
 
-  if (!ts.isExpression(tsNode)) return false;
+  if (!ts.isExpression(tsNode)) {
+    return false;
+  }
 
   const expectedType =
     getDeclaredParameterType(checker, tsNode) ??
@@ -436,7 +486,9 @@ const getDeclaredParameterType = (
 
   const index = call.arguments?.indexOf(argument) ?? -1;
 
-  if (index === -1) return undefined;
+  if (index === -1) {
+    return undefined;
+  }
 
   const declaration = checker.getResolvedSignature(call)?.getDeclaration();
 
@@ -444,11 +496,9 @@ const getDeclaredParameterType = (
 
   // A rest parameter's declared type is the array of arguments, not the type of
   // one; the contextual type is the better answer there.
-  if (parameter === undefined || parameter.dotDotDotToken !== undefined) {
-    return undefined;
-  }
-
-  return checker.getTypeAtLocation(parameter);
+  return parameter === undefined || parameter.dotDotDotToken !== undefined
+    ? undefined
+    : checker.getTypeAtLocation(parameter);
 };
 
 /**

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

@@ -453,3 +453,74 @@ describe('prefer-arr-uniq', () => {
     ],
   });
 });
+
+describe('prefer-arr-uniq through type wrappers', () => {
+  tester.run('prefer-arr-uniq', preferArrUniq, {
+    valid: [],
+    invalid: [
+      {
+        name: 'a Set wrapped in `as` or `satisfies`',
+        code: dedent`
+          declare const xs: readonly string[];
+          const a = Array.from(new Set(xs) as ReadonlySet<string>);
+          const b = [...(new Set(xs) satisfies ReadonlySet<string>)];
+        `,
+        output: dedent`
+          import { Arr } from 'ts-data-forge';
+          declare const xs: readonly string[];
+          const a = Arr.uniq(xs);
+          const b = Arr.uniq(xs);
+        `,
+        errors: [{ messageId: 'useArrUniq' }, { messageId: 'useArrUniq' }],
+      },
+      {
+        name: 'only suggests when the result is mutated through `!`',
+        code: dedent`
+          const xs = [3, 1, 3];
+          Array.from(new Set(xs))!.push(4);
+        `,
+        output: null,
+        errors: [
+          {
+            messageId: 'useArrUniq',
+            suggestions: [
+              {
+                messageId: 'suggestArrUniq',
+                output: dedent`
+                  import { Arr } from 'ts-data-forge';
+                  const xs = [3, 1, 3];
+                  Arr.uniq(xs)!.push(4);
+                `,
+              },
+            ],
+          },
+        ],
+      },
+      {
+        name: 'only suggests when a variable initialized through `!` is mutated',
+        code: dedent`
+          const xs = [3, 1, 3];
+          const ys = Array.from(new Set(xs))!;
+          ys.push(4);
+        `,
+        output: null,
+        errors: [
+          {
+            messageId: 'useArrUniq',
+            suggestions: [
+              {
+                messageId: 'suggestArrUniq',
+                output: dedent`
+                  import { Arr } from 'ts-data-forge';
+                  const xs = [3, 1, 3];
+                  const ys = Arr.uniq(xs)!;
+                  ys.push(4);
+                `,
+              },
+            ],
+          },
+        ],
+      },
+    ],
+  });
+});

package/src/rules/prefer-as-int.mts

@@ -3,7 +3,8 @@ import {
   type TSESLint,
   type TSESTree,
 } from '@typescript-eslint/utils';
-import { type DeepReadonly } from 'ts-type-forge';
+import type { DeepReadonly } from 'ts-type-forge';
+import { toArgumentText } from './ast-utils.mjs';
 import { brandedNumberTypeNameToFunctionName } from './branded-number-types.mjs';
 import {
   buildImportFixes,
@@ -38,47 +39,43 @@ export const preferAsInt: TSESLint.RuleModule<MessageIds, Options> = {
     const tsDataForgeImport = getTsDataForgeImport(program);
 
     const mut_nodesToFix: {
-      node: TSESTree.TSAsExpression;
+      node: TSESTree.TSAsExpression | TSESTree.TSTypeAssertion;
       typeName: string;
       functionName: string;
     }[] = [];
 
-    return {
-      TSAsExpression: (node) => {
-        const typeInfo = getBrandedNumberTypeInfo(node.typeAnnotation);
-
-        if (typeInfo === undefined) return;
+    // `x as Int` and `<Int>x` are the same assertion.
+    const collect = (
+      // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+      node: TSESTree.TSAsExpression | TSESTree.TSTypeAssertion,
+    ): void => {
+      const typeInfo = getBrandedNumberTypeInfo(node.typeAnnotation);
+
+      if (typeInfo === undefined) {
+        return;
+      }
+
+      mut_nodesToFix.push({
+        node,
+        typeName: typeInfo.typeName,
+        functionName: typeInfo.functionName,
+      });
+    };
 
-        mut_nodesToFix.push({
-          node,
-          typeName: typeInfo.typeName,
-          functionName: typeInfo.functionName,
-        });
-      },
+    return {
+      TSAsExpression: collect,
+      TSTypeAssertion: collect,
       'Program:exit': () => {
         const namedImports = getNamedImports(tsDataForgeImport);
 
         // Group nodes by function name to handle imports efficiently
-        const mut_functionNameToNodes = new Map<
-          string,
-          Readonly<{
-            node: TSESTree.TSAsExpression;
-            typeName: string;
-            functionName: string;
-          }>[]
-        >();
-
-        for (const nodeInfo of mut_nodesToFix) {
-          const mut_nodes =
-            mut_functionNameToNodes.get(nodeInfo.functionName) ?? [];
-
-          mut_nodes.push(nodeInfo);
-
-          mut_functionNameToNodes.set(nodeInfo.functionName, mut_nodes);
-        }
+        const functionNameToNodes = Map.groupBy(
+          mut_nodesToFix,
+          (nodeInfo) => nodeInfo.functionName,
+        );
 
         // Process each group
-        for (const [functionName, nodes] of mut_functionNameToNodes) {
+        for (const [functionName, nodes] of functionNameToNodes) {
           const hasImport = namedImports.includes(functionName);
 
           for (const [index, { node, typeName }] of nodes.entries()) {
@@ -90,7 +87,7 @@ export const preferAsInt: TSESLint.RuleModule<MessageIds, Options> = {
                 functionName,
               },
               fix: (fixer) => {
-                const replacement = `${functionName}(${sourceCode.getText(node.expression)})`;
+                const replacement = `${functionName}(${toArgumentText(node.expression, sourceCode)})`;
 
                 // Add import only for the first node of this function and only if not already imported
                 const importFixes =
@@ -114,18 +111,21 @@ export const preferAsInt: TSESLint.RuleModule<MessageIds, Options> = {
 const getBrandedNumberTypeInfo = (
   typeAnnotation: DeepReadonly<TSESTree.TypeNode>,
 ): Readonly<{ typeName: string; functionName: string }> | undefined => {
-  if (typeAnnotation.type !== AST_NODE_TYPES.TSTypeReference) return undefined;
+  if (typeAnnotation.type !== AST_NODE_TYPES.TSTypeReference) {
+    return undefined;
+  }
 
-  if (typeAnnotation.typeName.type !== AST_NODE_TYPES.Identifier)
+  if (typeAnnotation.typeName.type !== AST_NODE_TYPES.Identifier) {
     return undefined;
+  }
 
   const typeName = typeAnnotation.typeName.name;
 
-  if (!brandedNumberTypeNameToFunctionName.has(typeName)) return undefined;
+  if (!brandedNumberTypeNameToFunctionName.has(typeName)) {
+    return undefined;
+  }
 
   const functionName = brandedNumberTypeNameToFunctionName.get(typeName);
 
-  if (functionName === undefined) return undefined;
-
-  return { typeName, functionName };
+  return functionName === undefined ? undefined : { typeName, functionName };
 };

package/src/rules/prefer-as-int.test.mts

@@ -265,3 +265,54 @@ describe('prefer-as-int', () => {
     ],
   });
 }, 20000);
+
+describe('prefer-as-int through type wrappers', () => {
+  tester.run('prefer-as-int', preferAsInt, {
+    valid: [],
+    invalid: [
+      {
+        name: 'an angle-bracket assertion',
+        code: dedent`
+          import { asInt } from 'ts-data-forge';
+          declare const n: number;
+          const a = <Int>n;
+        `,
+        output: dedent`
+          import { asInt } from 'ts-data-forge';
+          declare const n: number;
+          const a = asInt(n);
+        `,
+        errors: [{ messageId: 'useBrandedNumberCastFunction' }],
+      },
+    ],
+  });
+}, 20000);
+
+describe('prefer-as-int with parenthesized operands', () => {
+  tester.run('prefer-as-int', preferAsInt, {
+    valid: [],
+    invalid: [
+      {
+        name: 'a sequence operand keeps its parentheses',
+        code: dedent`
+          import { asInt } from 'ts-data-forge';
+          declare const log: () => void;
+          declare const n: number;
+          const a = (log(), n) as Int;
+          const b = <Int>(log(), n);
+        `,
+        output: dedent`
+          import { asInt } from 'ts-data-forge';
+          declare const log: () => void;
+          declare const n: number;
+          const a = asInt((log(), n));
+          const b = asInt((log(), n));
+        `,
+        errors: [
+          { messageId: 'useBrandedNumberCastFunction' },
+          { messageId: 'useBrandedNumberCastFunction' },
+        ],
+      },
+    ],
+  });
+}, 20000);