eslint-rule-forge 0.3.1 → 0.4.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,
@@ -39,15 +36,12 @@ export const createPreferIsRecordAndHasKey = ({
         useIsRecordAndHasKey: `Replace \`{{original}}\` with \`isRecord({{objName}}) && hasKey({{objName}}, {{keyName}})\` from ${moduleName}.`,
         useHasKey: `Replace \`{{original}}\` with \`hasKey({{objName}}, {{keyName}})\` from ${moduleName}.`,
       },
+      defaultOptions: [],
     },
 
     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
@@ -158,87 +152,69 @@ 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,
             });
           }
         },
       };
     },
-    defaultOptions: [],
   }) as const;
 
 /**

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();
 
@@ -123,15 +118,12 @@ const createSafeParseRule = <MessageId extends string>(
       fixable: 'code',
       schema: [],
       messages,
+      defaultOptions: [],
     },
 
     create: (context) => {
       const sourceCode = context.sourceCode;
 
-      const program = sourceCode.ast;
-
-      const moduleImports = getImportDeclarations(program, moduleName);
-
       const mut_nodesToFix: {
         node: TSESTree.CallExpression;
         argExpression: TSESTree.Expression;
@@ -168,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({
@@ -190,28 +185,26 @@ 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)`,
+                      ),
+                    ],
             });
           }
         },
       };
     },
-    defaultOptions: [],
   } as const;
 };
 

package/src/type-wrappers.mts

@@ -119,7 +119,7 @@ export const typeHoldsAtEveryLayer = (
   });
 };
 
-const TYPE_WRAPPERS: ReadonlySet<AST_NODE_TYPES> = new Set([
+const TYPE_WRAPPERS: ReadonlySet<AST_NODE_TYPES> = new Set<AST_NODE_TYPES>([
   AST_NODE_TYPES.TSAsExpression,
   AST_NODE_TYPES.TSNonNullExpression,
   AST_NODE_TYPES.TSSatisfiesExpression,