eslint-rule-forge 0.3.2 → 0.5.0

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

@@ -3,11 +3,8 @@ import {
   type TSESLint,
   type TSESTree,
 } from '@typescript-eslint/utils';
-import {
-  buildNamedImportFix,
-  getImportDeclarations,
-  getNamedImports,
-} from '../imports.mjs';
+import { hasForeignBinding } from '../bindings.mjs';
+import { bindValueImports } from '../imports.mjs';
 import { getRangeWithParens, parenthesesDepth } from '../parentheses.mjs';
 import { skipTypeWrappers } from '../type-wrappers.mjs';
 
@@ -39,11 +36,8 @@ export const createPreferIsNonNullObject = ({
     create: (context) => {
       const sourceCode = context.sourceCode;
 
-      const program = sourceCode.ast;
-
-      const moduleImports = getImportDeclarations(program, moduleName);
-
-      const mut_pairsToFix: NonNullObjectPair[] = [];
+      const mut_pairsToFix: (NonNullObjectPair &
+        Readonly<{ chain: TSESTree.LogicalExpression }>)[] = [];
 
       return {
         LogicalExpression: (node) => {
@@ -52,42 +46,43 @@ export const createPreferIsNonNullObject = ({
             return;
           }
 
-          mut_pairsToFix.push(...findNonNullObjectPairs(sourceCode, node));
+          mut_pairsToFix.push(
+            ...findNonNullObjectPairs(sourceCode, node).map((pair) => ({
+              ...pair,
+              chain: node,
+            })),
+          );
         },
         'Program:exit': () => {
-          const hasIsNonNullObjectImport =
-            getNamedImports(moduleImports).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()) {
+          const binding = bindValueImports(sourceCode, moduleName, [
+            'isNonNullObject',
+          ]);
+
+          const localName = binding?.localNames[0];
+
+          // Every fix brings `isNonNullObject` into scope itself, so that one
+          // applied alone (an editor's quick fix) is complete.
+          for (const { range, identifierName, chain } of mut_pairsToFix) {
+            const loc = {
+              start: sourceCode.getLocFromIndex(range[0]),
+              end: sourceCode.getLocFromIndex(range[1]),
+            } as const;
+
             context.report({
-              loc: {
-                start: sourceCode.getLocFromIndex(range[0]),
-                end: sourceCode.getLocFromIndex(range[1]),
-              },
+              loc,
               messageId: 'useIsNonNullObject',
-              fix: (fixer) => {
-                const replacement = `isNonNullObject(${identifierName})`;
-
-                const importFixes =
-                  index === 0 && !hasIsNonNullObjectImport
-                    ? buildNamedImportFix(fixer, program, moduleName, [
-                        'isNonNullObject',
-                      ])
-                    : [];
-
-                return [
-                  ...importFixes,
-                  fixer.replaceTextRange(range, replacement),
-                ];
-              },
+              fix:
+                binding === undefined ||
+                localName === undefined ||
+                hasForeignBinding(sourceCode, chain, localName, moduleName)
+                  ? null
+                  : (fixer) => [
+                      ...binding.edits(fixer),
+                      fixer.replaceTextRange(
+                        range,
+                        `${localName}(${identifierName})`,
+                      ),
+                    ],
             });
           }
         },
@@ -120,51 +115,8 @@ const isChainOperand = (
   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.
+ * 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
@@ -183,26 +135,11 @@ const chainOperands = (
 // 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,
+const isLiteralOf = (
   // 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;
-};
+  node: TSESTree.Node,
+  value: string | null,
+): boolean => node.type === AST_NODE_TYPES.Literal && node.value === value;
 
 /** `u` of `typeof u === 'object'`, in either operand order. */
 const getTypeofObjectIdentifierName = (
@@ -242,8 +179,8 @@ const getTypeofObjectIdentifierName = (
 
 /**
  * `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.
+ * `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
@@ -269,8 +206,66 @@ const getNonNullCheckIdentifierName = (
   return checked?.type === AST_NODE_TYPES.Identifier ? checked.name : undefined;
 };
 
-const isLiteralOf = (
+/**
+ * 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
-  node: TSESTree.Node,
-  value: string | null,
-): boolean => node.type === AST_NODE_TYPES.Literal && node.value === value;
+  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;
+};
+
+/**
+ * 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);
+};

package/src/rules/prefer-is-record-and-has-key.mts

@@ -4,11 +4,8 @@ import {
   type TSESTree,
 } from '@typescript-eslint/utils';
 import * as ts from 'typescript';
-import {
-  buildNamedImportFix,
-  getImportDeclarations,
-  getNamedImports,
-} from '../imports.mjs';
+import { hasForeignBinding } from '../bindings.mjs';
+import { bindValueImports } from '../imports.mjs';
 import { getArgumentText } from '../parentheses.mjs';
 import {
   isIdentifierNamed,
@@ -45,18 +42,14 @@ export const createPreferIsRecordAndHasKey = ({
     create: (context) => {
       const sourceCode = context.sourceCode;
 
-      const program = sourceCode.ast;
-
-      const moduleImports = getImportDeclarations(program, moduleName);
-
       /**
        * Whether the `isRecord(...)` half of the rewrite would be dead code
        * because the object already satisfies `hasKey`'s
-       * `R extends UnknownRecord` constraint, at every layer of type
-       * wrappers: an array cast to a record is still rejected by `isRecord`,
-       * and a record widened to one that may be an array is the author saying
-       * it may need the guard. Without type information nothing is known, so
-       * the guard is kept.
+       * `R extends UnknownRecord` constraint, at every layer of type wrappers:
+       * an array cast to a record is still rejected by `isRecord`, and a record
+       * widened to one that may be an array is the author saying it may need
+       * the guard. Without type information nothing is known, so the guard is
+       * kept.
        */
       const isKnownRecord = (
         // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
@@ -159,81 +152,64 @@ export const createPreferIsRecordAndHasKey = ({
         },
 
         'Program:exit': () => {
-          const namedImports = getNamedImports(moduleImports);
-
-          const rewrites = mut_nodesToFix.map((entry) => {
+          // Bound once for each shape of rewrite: a file may import `hasKey`
+          // but not `isRecord`, which only the rewrites that need it add.
+          const withIsRecord = bindValueImports(sourceCode, moduleName, [
+            'isRecord',
+            'hasKey',
+          ]);
+
+          const hasKeyOnly = bindValueImports(sourceCode, moduleName, [
+            'hasKey',
+          ]);
+
+          for (const { node, objExpression, keyExpression } of mut_nodesToFix) {
             // A record-typed object makes the `isRecord(...)` conjunct always
             // true, so it is left out of the replacement entirely.
-            const needsIsRecord = !isKnownRecord(entry.objExpression);
+            const needsIsRecord = !isKnownRecord(objExpression);
 
-            return {
-              ...entry,
-              needsIsRecord,
-              // `isRecord(obj) && hasKey(obj, key)` evaluates `obj` twice.
-              fixable: !needsIsRecord || isSideEffectFree(entry.objExpression),
-            };
-          });
-
-          const fixableRewrites = rewrites.filter(({ fixable }) => fixable);
+            const binding = needsIsRecord ? withIsRecord : hasKeyOnly;
 
-          const importsToAdd: readonly string[] =
-            fixableRewrites.length === 0
-              ? []
-              : [
-                  ...(fixableRewrites.some(
-                    ({ needsIsRecord }) => needsIsRecord,
-                  ) && !namedImports.includes('isRecord')
-                    ? ['isRecord']
-                    : []),
-                  ...(namedImports.includes('hasKey') ? [] : ['hasKey']),
-                ];
+            const hasKeyName = binding?.localNames.at(-1);
 
-          const importCarrier = fixableRewrites[0];
-
-          for (const rewrite of rewrites) {
-            const { node, objExpression, keyExpression, needsIsRecord } =
-              rewrite;
+            const isRecordName = needsIsRecord
+              ? binding?.localNames[0]
+              : undefined;
 
             const objText = getArgumentText(sourceCode, objExpression);
 
             const keyText = getArgumentText(sourceCode, keyExpression);
 
-            const originalText = sourceCode.getText(node);
+            const fixable =
+              binding !== undefined &&
+              hasKeyName !== undefined &&
+              (!needsIsRecord || isRecordName !== undefined) &&
+              // `isRecord(obj) && hasKey(obj, key)` evaluates `obj` twice.
+              (!needsIsRecord || isSideEffectFree(objExpression)) &&
+              binding.localNames.every(
+                (name) =>
+                  !hasForeignBinding(sourceCode, node, name, moduleName),
+              );
 
             context.report({
               node,
               messageId: needsIsRecord ? 'useIsRecordAndHasKey' : 'useHasKey',
               data: {
-                original: originalText,
+                original: sourceCode.getText(node),
                 objName: objText,
                 keyName: keyText,
               },
-              fix: !rewrite.fixable
-                ? undefined
-                : (fixer) => {
-                    const replacement = needsIsRecord
-                      ? `(isRecord(${objText}) && hasKey(${objText}, ${keyText}))`
-                      : `hasKey(${objText}, ${keyText})`;
-
-                    // All import fixes have to live on the first fixable
-                    // report: `insertTextBefore(program, …)` produces
-                    // overlapping ranges otherwise and only one of them would
-                    // survive a pass.
-                    const importFixes =
-                      rewrite === importCarrier && importsToAdd.length > 0
-                        ? buildNamedImportFix(
-                            fixer,
-                            program,
-                            moduleName,
-                            importsToAdd,
-                          )
-                        : [];
-
-                    return [
-                      ...importFixes,
-                      fixer.replaceText(node, replacement),
-                    ];
-                  },
+              fix: fixable
+                ? (fixer) => [
+                    ...binding.edits(fixer),
+                    fixer.replaceText(
+                      node,
+                      needsIsRecord
+                        ? `(${isRecordName}(${objText}) && ${hasKeyName}(${objText}, ${keyText}))`
+                        : `${hasKeyName}(${objText}, ${keyText})`,
+                    ),
+                  ]
+                : null,
             });
           }
         },