eslint-rule-forge 0.3.2 → 0.4.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})`,
+                      ),
+                    ],
             });
           }
         },

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,10 +42,6 @@ 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
@@ -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,
             });
           }
         },

package/src/rules/prefer-safe-parse.mts

@@ -5,11 +5,8 @@ import {
 } from '@typescript-eslint/utils';
 import type { ReadonlyRecord } from 'ts-type-forge';
 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,
@@ -111,8 +108,6 @@ const createSafeParseRule = <MessageId extends string>(
     ) => boolean;
   }>,
 ): TSESLint.RuleModule<MessageId, readonly []> => {
-  const parseFunction = `${namespace}.${method}` as const;
-
   // Sorted, as an import sorter would write them.
   const requiredImports = [namespace, 'Result'].toSorted();
 
@@ -129,10 +124,6 @@ const createSafeParseRule = <MessageId extends string>(
     create: (context) => {
       const sourceCode = context.sourceCode;
 
-      const program = sourceCode.ast;
-
-      const moduleImports = getImportDeclarations(program, moduleName);
-
       const mut_nodesToFix: {
         node: TSESTree.CallExpression;
         argExpression: TSESTree.Expression;
@@ -169,19 +160,22 @@ const createSafeParseRule = <MessageId extends string>(
           mut_nodesToFix.push({ node, argExpression: firstArg });
         },
         'Program:exit': () => {
-          const namedImports = getNamedImports(moduleImports);
-
-          const missingImports = requiredImports.filter(
-            (name) => !namedImports.includes(name),
+          const binding = bindValueImports(
+            sourceCode,
+            moduleName,
+            requiredImports,
           );
 
-          // The import fix lives on the first report only:
-          // `insertTextBefore(program, …)` produces overlapping ranges
-          // otherwise and only one of them would survive a pass.
-          for (const [
-            index,
-            { node, argExpression },
-          ] of mut_nodesToFix.entries()) {
+          const localNameOf = (name: string): string | undefined =>
+            binding?.localNames[requiredImports.indexOf(name)];
+
+          const namespaceName = localNameOf(namespace);
+
+          const resultName = localNameOf('Result');
+
+          // Every fix brings its names into scope itself, so that one applied
+          // alone (an editor's quick fix) is complete.
+          for (const { node, argExpression } of mut_nodesToFix) {
             const argText = getArgumentText(sourceCode, argExpression);
 
             context.report({
@@ -191,22 +185,21 @@ const createSafeParseRule = <MessageId extends string>(
                 original: sourceCode.getText(node),
                 argName: argText,
               },
-              fix: (fixer) => {
-                const core =
-                  `Result.unwrapOkOr(${parseFunction}(${argText}), Number.NaN)` as const;
-
-                const importFixes =
-                  index === 0 && missingImports.length > 0
-                    ? buildNamedImportFix(
-                        fixer,
-                        program,
-                        moduleName,
-                        missingImports,
-                      )
-                    : ([] as const);
-
-                return [...importFixes, fixer.replaceText(node, core)];
-              },
+              fix:
+                binding === undefined ||
+                namespaceName === undefined ||
+                resultName === undefined ||
+                [namespaceName, resultName].some((name) =>
+                  hasForeignBinding(sourceCode, node, name, moduleName),
+                )
+                  ? null
+                  : (fixer) => [
+                      ...binding.edits(fixer),
+                      fixer.replaceText(
+                        node,
+                        `${resultName}.unwrapOkOr(${namespaceName}.${method}(${argText}), Number.NaN)`,
+                      ),
+                    ],
             });
           }
         },