eslint-plugin-ts-data-forge 0.10.5 → 0.10.7

package/src/rules/no-unnecessary-type-guard.test.mts

@@ -406,13 +406,73 @@ describe('no-unnecessary-type-guard', () => {
           const y = isNonNullish(x);
         `,
         output: dedent`
-          import { isNotNull } from 'ts-data-forge';
-          import { isNonNullish } from 'ts-data-forge';
+          import { isNonNullish, isNotNull } from 'ts-data-forge';
           declare const x: string | null;
           const y = isNotNull(x);
         `,
         errors: [{ messageId: 'replaceTypeGuard' }],
       },
+      {
+        name: 'the message names an aliased replacement guard by its local name',
+        code: dedent`
+          import { isNonNullish, isNotNull as inn } from 'ts-data-forge';
+          declare const x: string | null;
+          const y = isNonNullish(x);
+        `,
+        output: dedent`
+          import { isNonNullish, isNotNull as inn } from 'ts-data-forge';
+          declare const x: string | null;
+          const y = inn(x);
+        `,
+        errors: [
+          {
+            messageId: 'replaceTypeGuard',
+            data: { from: 'isNonNullish', to: 'inn' },
+          },
+        ],
+      },
+      {
+        name: 'several reports bind each replacement guard they write',
+        code: dedent`
+          import { isNonNullish } from 'ts-data-forge';
+          declare const x: string | null;
+          declare const z: string | undefined;
+          const a = isNonNullish(x);
+          const b = isNonNullish(x);
+          const c = isNonNullish(z);
+        `,
+        output: [
+          dedent`
+            import { isNonNullish, isNotNull } from 'ts-data-forge';
+            declare const x: string | null;
+            declare const z: string | undefined;
+            const a = isNotNull(x);
+            const b = isNonNullish(x);
+            const c = isNonNullish(z);
+          `,
+          dedent`
+            import { isNonNullish, isNotNull, isNotUndefined } from 'ts-data-forge';
+            declare const x: string | null;
+            declare const z: string | undefined;
+            const a = isNotNull(x);
+            const b = isNonNullish(x);
+            const c = isNotUndefined(z);
+          `,
+          dedent`
+            import { isNonNullish, isNotNull, isNotUndefined } from 'ts-data-forge';
+            declare const x: string | null;
+            declare const z: string | undefined;
+            const a = isNotNull(x);
+            const b = isNotNull(x);
+            const c = isNotUndefined(z);
+          `,
+        ],
+        errors: [
+          { messageId: 'replaceTypeGuard' },
+          { messageId: 'replaceTypeGuard' },
+          { messageId: 'replaceTypeGuard' },
+        ],
+      },
       {
         name: 'isNullish that only matches undefined -> isUndefined',
         code: dedent`

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

@@ -6,11 +6,8 @@ import {
   type TSESTree,
 } from '@typescript-eslint/utils';
 import {
-  buildNamedImportFix,
   createGetLayerTypes,
   getArgumentText,
-  getImportDeclarations,
-  getImportedLocalName,
   negationOf,
   prefixedNegationOf,
   skipTypeWrappers,
@@ -19,7 +16,7 @@ import {
 import { Arr, hasKey, isRecord } from 'ts-data-forge';
 import type { FixedLengthTuple } from 'ts-type-forge';
 import * as ts from 'typescript';
-import { TS_DATA_FORGE_MODULE } from './constants.mjs';
+import { tsDataForgeValuesAt } from './import-binding.mjs';
 import { needsMutableResult } from './mutable-result.mjs';
 
 type Options = readonly [];
@@ -34,8 +31,8 @@ type Match = Readonly<{
 }>;
 
 /**
- * The callback of `xs.flatMap((x) => (cond ? [a, b] : []))` decides per
- * element whether to keep it and what to keep. Written as a loop, that is
+ * The callback of `xs.flatMap((x) => (cond ? [a, b] : []))` decides per element
+ * whether to keep it and what to keep. Written as a loop, that is
  *
  * ```ts
  * Arr.generate(function* () {
@@ -106,13 +103,6 @@ export const preferArrGenerate: TSESLint.RuleModule<MessageIds, Options> = {
   create: (context) => {
     const sourceCode = context.sourceCode;
 
-    const program = sourceCode.ast;
-
-    const tsDataForgeImports = getImportDeclarations(
-      program,
-      TS_DATA_FORGE_MODULE,
-    );
-
     const services = sourceCode.parserServices;
 
     const tsProgram = services?.program ?? undefined;
@@ -132,8 +122,8 @@ export const preferArrGenerate: TSESLint.RuleModule<MessageIds, Options> = {
       esTreeNodeToTSNodeMap,
     });
 
-    // The negation is the test of the loop's `if`, where only its truthiness
-    // is read, so `!!a` may always be written `a`.
+    // The negation is the test of the loop's `if`, where only its truthiness is
+    // read, so `!!a` may always be written `a`.
     const negationContext: NegationContext = {
       sourceCode,
       checker,
@@ -146,9 +136,10 @@ export const preferArrGenerate: TSESLint.RuleModule<MessageIds, Options> = {
       node: TSESTree.Node,
     ): ts.Node | undefined => esTreeNodeToTSNodeMap.get(node);
 
-    const arrLocalName = getImportedLocalName(tsDataForgeImports, 'Arr');
+    // The name the rewrite writes, and, at a node, the edits that bind it.
+    const arr = tsDataForgeValuesAt(sourceCode, ['Arr']);
 
-    const arrName = arrLocalName ?? 'Arr';
+    const arrName = arr.localNames[0] ?? 'Arr';
 
     const mut_matches: Match[] = [];
 
@@ -172,8 +163,8 @@ export const preferArrGenerate: TSESLint.RuleModule<MessageIds, Options> = {
 
         const callback = node.arguments[0];
 
-        // A wrapper around the callback may be what types its parameter, so
-        // a wrapped callback is not unwrapped.
+        // A wrapper around the callback may be what types its parameter, so a
+        // wrapped callback is not unwrapped.
         if (
           callback.type !== AST_NODE_TYPES.ArrowFunctionExpression ||
           callback.async ||
@@ -291,45 +282,53 @@ export const preferArrGenerate: TSESLint.RuleModule<MessageIds, Options> = {
               ),
             true,
           ) &&
-          !losesComments(sourceCode, callback, shape) &&
+          !losesComments(
+            sourceCode,
+            node,
+            [
+              receiver.range,
+              param.range,
+              ...(typeArguments === undefined ? [] : [typeArguments.range]),
+            ],
+            shape,
+          ) &&
           !needsMutableResult(sourceCode, checker, getTsNode, node);
 
         mut_matches.push({ node, replacement, autofixable });
       },
       'Program:exit': () => {
-        // The import is added by the first fix only, so that several fixes do
-        // not insert it at the same position. When the first match is not
-        // autofixable, the first autofixable one carries it instead.
-        const firstAutofixable = mut_matches.find((m) => m.autofixable);
-
+        // Every fix brings `Arr` into scope itself, so that one applied alone
+        // (an editor's quick fix) is complete.
         for (const match of mut_matches) {
-          const buildFix =
-            (withImport: boolean): TSESLint.ReportFixFunction =>
-            (fixer) => [
-              ...(withImport && arrLocalName === undefined
-                ? buildNamedImportFix(fixer, program, TS_DATA_FORGE_MODULE, [
-                    'Arr',
-                  ])
-                : []),
-              fixer.replaceText(match.node, match.replacement),
-            ];
+          const binding = arr.at(match.node);
+
+          const fix: TSESLint.ReportFixFunction | null =
+            binding === undefined
+              ? null
+              : (fixer) => [
+                  ...binding.edits(fixer),
+                  fixer.replaceText(match.node, match.replacement),
+                ];
 
           if (match.autofixable) {
             context.report({
               node: match.node,
               messageId: 'useArrGenerate',
-              fix: buildFix(match === firstAutofixable),
+              fix,
             });
           } else {
             context.report({
               node: match.node,
               messageId: 'useArrGenerate',
-              suggest: [
-                {
-                  messageId: 'suggestArrGenerate',
-                  fix: buildFix(true),
-                },
-              ],
+              suggest:
+                fix === null
+                  ? []
+                  : [
+                      {
+                        messageId: 'suggestArrGenerate',
+                        fix,
+                      },
+                    ],
             });
           }
         }
@@ -452,6 +451,63 @@ const getFilterMapShape = (
   };
 };
 
+/** The whitespace at the start of the line that `index` is on. */
+const lineIndentOf = (
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  sourceCode: TSESLint.SourceCode,
+  index: number,
+): string => {
+  const { line } = sourceCode.getLocFromIndex(index);
+
+  const lineText = sourceCode.lines[line - 1] ?? '';
+
+  return /^\s*/u.exec(lineText)?.[0] ?? '';
+};
+
+/**
+ * `text`, the source at `range`, with every line after the first shifted from
+ * the indentation of the line `range` starts on to `targetIndent`. Left as it
+ * is when a template literal or string spans lines inside it, since shifting
+ * those lines would change the string.
+ */
+const reindent = (
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  sourceCode: TSESLint.SourceCode,
+  range: FixedLengthTuple<2, number>,
+  targetIndent: string,
+  text: string,
+): string => {
+  if (!text.includes('\n')) {
+    return text;
+  }
+
+  const spansLines = sourceCode.ast.tokens.some(
+    (token) =>
+      range[0] <= token.range[0] &&
+      token.range[1] <= range[1] &&
+      (token.type === AST_TOKEN_TYPES.Template ||
+        token.type === AST_TOKEN_TYPES.String) &&
+      token.loc.start.line !== token.loc.end.line,
+  );
+
+  if (spansLines) {
+    return text;
+  }
+
+  const sourceIndent = lineIndentOf(sourceCode, range[0]);
+
+  const [first, ...rest] = text.split('\n');
+
+  return [
+    first,
+    ...rest.map((line) =>
+      line.startsWith(sourceIndent)
+        ? `${targetIndent}${line.slice(sourceIndent.length)}`
+        : line,
+    ),
+  ].join('\n');
+};
+
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
 const buildReplacement = ({
   sourceCode,
@@ -534,19 +590,29 @@ const buildReplacement = ({
 };
 
 /**
- * Whether a comment inside `callback` lies outside every piece of source the
- * rewrite carries over, and would therefore be dropped.
+ * Whether a comment inside `node`, the call the fix replaces, lies outside
+ * every range the rewrite copies verbatim, and would therefore be dropped.
+ *
+ * `copied` lists those ranges besides the shape's: the receiver, the type
+ * arguments and the parameter. The test counts only when it is copied as it is:
+ * a negated test is rebuilt by `negationOf`, which can drop a comment (one
+ * between the operands of `a && b` is gone from `!a || !b`), so any comment in
+ * one keeps the fix a suggestion, even where the negation carries it over. A
+ * comment between the receiver and `.flatMap`, after `flatMap(` or after the
+ * callback is in none of the ranges.
  */
 const losesComments = (
   // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
   sourceCode: TSESLint.SourceCode,
   // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-  callback: TSESTree.ArrowFunctionExpression,
+  node: TSESTree.CallExpression,
+  copied: readonly FixedLengthTuple<2, number>[],
   // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
   shape: FilterMapShape,
 ): boolean => {
   const keptRanges: readonly FixedLengthTuple<2, number>[] = [
-    shape.test.range,
+    ...copied,
+    ...(shape.negated ? ([] as const) : ([shape.test.range] as const)),
     ...shape.elements.map((element) => element.range),
     ...(shape.preludeRange === undefined
       ? ([] as const)
@@ -554,7 +620,7 @@ const losesComments = (
   ] as const;
 
   return sourceCode
-    .getCommentsInside(callback)
+    .getCommentsInside(node)
     .some((comment) =>
       keptRanges.every(
         ([start, end]) =>
@@ -563,63 +629,6 @@ const losesComments = (
     );
 };
 
-/**
- * `text`, the source at `range`, with every line after the first shifted from
- * the indentation of the line `range` starts on to `targetIndent`. Left as it
- * is when a template literal or string spans lines inside it, since shifting
- * those lines would change the string.
- */
-const reindent = (
-  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-  sourceCode: TSESLint.SourceCode,
-  range: FixedLengthTuple<2, number>,
-  targetIndent: string,
-  text: string,
-): string => {
-  if (!text.includes('\n')) {
-    return text;
-  }
-
-  const spansLines = sourceCode.ast.tokens.some(
-    (token) =>
-      range[0] <= token.range[0] &&
-      token.range[1] <= range[1] &&
-      (token.type === AST_TOKEN_TYPES.Template ||
-        token.type === AST_TOKEN_TYPES.String) &&
-      token.loc.start.line !== token.loc.end.line,
-  );
-
-  if (spansLines) {
-    return text;
-  }
-
-  const sourceIndent = lineIndentOf(sourceCode, range[0]);
-
-  const [first, ...rest] = text.split('\n');
-
-  return [
-    first,
-    ...rest.map((line) =>
-      line.startsWith(sourceIndent)
-        ? `${targetIndent}${line.slice(sourceIndent.length)}`
-        : line,
-    ),
-  ].join('\n');
-};
-
-/** The whitespace at the start of the line that `index` is on. */
-const lineIndentOf = (
-  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-  sourceCode: TSESLint.SourceCode,
-  index: number,
-): string => {
-  const { line } = sourceCode.getLocFromIndex(index);
-
-  const lineText = sourceCode.lines[line - 1] ?? '';
-
-  return /^\s*/u.exec(lineText)?.[0] ?? '';
-};
-
 /** Whether `node`, with its type wrappers taken off, is a `….filter(…)` call. */
 const isFilterCall = (
   // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
@@ -642,78 +651,30 @@ const isFilterCall = (
 };
 
 /**
- * Whether `node`, a reference or a member access, has a type here narrower
- * than its declared one, by a narrowing that a function created here would not
- * see. TypeScript keeps the narrowing of a `const`, and of a parameter or `let`
- * that is never reassigned, inside a closure; it drops every other one,
- * including any narrowing of a property.
+ * Whether `type` is an array or tuple, or a union of them, or an intersection
+ * with one in it (`readonly T[] & Brand`).
  */
-const isNarrowedHere = (
-  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-  sourceCode: TSESLint.SourceCode,
+const isArrayOrTupleType = (
   // 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,
-  isReceiver: boolean,
+  type: ts.Type,
 ): boolean => {
-  if (
-    node.type !== AST_NODE_TYPES.Identifier &&
-    node.type !== AST_NODE_TYPES.MemberExpression
-  ) {
-    return false;
-  }
-
-  // A method about to be called (`xs.flat()`): its type is that of the method,
-  // which no narrowing of interest changes.
-  if (
-    node.parent.type === AST_NODE_TYPES.CallExpression &&
-    node.parent.callee === node
-  ) {
-    return false;
-  }
-
-  if (node.type === AST_NODE_TYPES.Identifier) {
-    if (!isReference(node)) {
-      return false;
-    }
-
-    const variable = ASTUtils.findVariable(sourceCode.getScope(node), node);
-
-    if (
-      variable?.references.every(
-        (reference) => !reference.isWrite() || reference.init === true,
-      ) === true
-    ) {
-      return false;
-    }
-  }
-
-  const tsNode = getTsNode(node);
-
-  if (tsNode === undefined) {
-    return false;
-  }
-
-  const declaredType = getDeclaredType(checker, tsNode);
-
-  const type = checker.getTypeAtLocation(tsNode);
+  const resolved =
+    (type.flags & ts.TypeFlags.TypeParameter) !== 0
+      ? (checker.getBaseConstraintOfType(type) ?? type)
+      : type;
 
-  return (
-    declaredType !== undefined &&
-    declaredType !== type &&
-    // The loop only iterates the receiver itself, so a narrowing that leaves
-    // it an array of the same elements (`Arr.isNonEmpty(xs)`) loses nothing.
-    !(isReceiver && iteratesTheSame(checker, declaredType, type))
-  );
+  return resolved.isUnion()
+    ? resolved.types.every((t) => isArrayOrTupleType(checker, t))
+    : resolved.isIntersection()
+      ? resolved.types.some((t) => isArrayOrTupleType(checker, t))
+      : checker.isArrayType(resolved) || checker.isTupleType(resolved);
 };
 
 /**
- * Whether two types are both arrays or tuples whose elements have one type,
- * as the declared and the narrowed type of `xs` after `Arr.isNonEmpty(xs)`
- * are.
+ * Whether two types are both arrays or tuples whose elements have one type, as
+ * the declared and the narrowed type of `xs` after `Arr.isNonEmpty(xs)` are.
  */
 const iteratesTheSame = (
   // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
@@ -740,8 +701,8 @@ const iteratesTheSame = (
  * `undefined` when there is none to compare with (an index read with no
  * property behind it, which nothing narrows).
  *
- * A property's is read off the type of the object it is accessed on, which
- * also covers a property of a mapped type (`Readonly<…>`), whose symbol has no
+ * A property's is read off the type of the object it is accessed on, which also
+ * covers a property of a mapped type (`Readonly<…>`), whose symbol has no
  * declaration of its own. A variable's is the type at its declaration
  * (`checker.getTypeOfSymbol` would say the same, but is missing before
  * TypeScript 5.1).
@@ -787,10 +748,97 @@ const getDeclaredType = (
     : checker.getTypeOfSymbolAtLocation(symbol, declaration);
 };
 
+/** Whether an identifier reads a binding, rather than naming a property or a key. */
+const isReference = (
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  node: TSESTree.Identifier,
+): boolean => {
+  const { parent } = node;
+
+  return !(
+    (parent.type === AST_NODE_TYPES.MemberExpression &&
+      parent.property === node &&
+      !parent.computed) ||
+    (parent.type === AST_NODE_TYPES.Property &&
+      parent.key === node &&
+      !parent.computed &&
+      !parent.shorthand)
+  );
+};
+
 /**
- * Whether the binding `identifier` reads is declared inside `container`, as
- * the parameter of an arrow function in the receiver is: the loop variable
- * does not shadow it.
+ * Whether `node`, a reference or a member access, has a type here narrower than
+ * its declared one, by a narrowing that a function created here would not see.
+ * TypeScript keeps the narrowing of a `const`, and of a parameter or `let` that
+ * is never reassigned, inside a closure; it drops every other one, including
+ * any narrowing of a property.
+ */
+const isNarrowedHere = (
+  // 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,
+  isReceiver: boolean,
+): boolean => {
+  if (
+    node.type !== AST_NODE_TYPES.Identifier &&
+    node.type !== AST_NODE_TYPES.MemberExpression
+  ) {
+    return false;
+  }
+
+  // A method about to be called (`xs.flat()`): its type is that of the method,
+  // which no narrowing of interest changes.
+  if (
+    node.parent.type === AST_NODE_TYPES.CallExpression &&
+    node.parent.callee === node
+  ) {
+    return false;
+  }
+
+  if (node.type === AST_NODE_TYPES.Identifier) {
+    if (!isReference(node)) {
+      return false;
+    }
+
+    const variable = ASTUtils.findVariable(sourceCode.getScope(node), node);
+
+    if (
+      variable?.references.every(
+        (reference) => !reference.isWrite() || reference.init === true,
+      ) === true
+    ) {
+      return false;
+    }
+  }
+
+  const tsNode = getTsNode(node);
+
+  if (tsNode === undefined) {
+    return false;
+  }
+
+  const declaredType = getDeclaredType(checker, tsNode);
+
+  const type = checker.getTypeAtLocation(tsNode);
+
+  return (
+    declaredType !== undefined &&
+    declaredType !== type &&
+    // The loop only iterates the receiver itself, so a narrowing that leaves it
+    // an array of the same elements (`Arr.isNonEmpty(xs)`) loses nothing.
+    !(isReceiver && iteratesTheSame(checker, declaredType, type))
+  );
+};
+
+/**
+ * Whether the binding `identifier` reads is declared inside `container`, as the
+ * parameter of an arrow function in the receiver is: the loop variable does not
+ * shadow it.
  */
 const isBoundWithin = (
   // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
@@ -816,23 +864,8 @@ const isBoundWithin = (
   );
 };
 
-/** Whether an identifier reads a binding, rather than naming a property or a key. */
-const isReference = (
-  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-  node: TSESTree.Identifier,
-): boolean => {
-  const { parent } = node;
-
-  return !(
-    (parent.type === AST_NODE_TYPES.MemberExpression &&
-      parent.property === node &&
-      !parent.computed) ||
-    (parent.type === AST_NODE_TYPES.Property &&
-      parent.key === node &&
-      !parent.computed &&
-      !parent.shorthand)
-  );
-};
+const isNode = (value: unknown): value is TSESTree.Node =>
+  isRecord(value) && hasKey(value, 'type') && typeof value.type === 'string';
 
 /**
  * Whether `node` or a node inside it satisfies `predicate`. A nested
@@ -877,9 +910,6 @@ const someDescendant = (
   });
 };
 
-const isNode = (value: unknown): value is TSESTree.Node =>
-  isRecord(value) && hasKey(value, 'type') && typeof value.type === 'string';
-
 const isReturnStatement = (
   // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
   node: TSESTree.Node,
@@ -894,25 +924,3 @@ const rebindsInGenerator = (
   node.type === AST_NODE_TYPES.Super ||
   node.type === AST_NODE_TYPES.MetaProperty ||
   (node.type === AST_NODE_TYPES.Identifier && node.name === 'arguments');
-
-/**
- * Whether `type` is an array or tuple, or a union of them, or an intersection
- * with one in it (`readonly T[] & Brand`).
- */
-const isArrayOrTupleType = (
-  // 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 resolved =
-    (type.flags & ts.TypeFlags.TypeParameter) !== 0
-      ? (checker.getBaseConstraintOfType(type) ?? type)
-      : type;
-
-  return resolved.isUnion()
-    ? resolved.types.every((t) => isArrayOrTupleType(checker, t))
-    : resolved.isIntersection()
-      ? resolved.types.some((t) => isArrayOrTupleType(checker, t))
-      : checker.isArrayType(resolved) || checker.isTupleType(resolved);
-};