eslint-rule-forge 0.5.0 → 0.6.0

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

@@ -3,8 +3,7 @@ import {
   type TSESLint,
   type TSESTree,
 } from '@typescript-eslint/utils';
-import { hasForeignBinding } from '../bindings.mjs';
-import { bindValueImports } from '../imports.mjs';
+import { bindValueImportsAt } from '../imports.mjs';
 import { getRangeWithParens, parenthesesDepth } from '../parentheses.mjs';
 import { skipTypeWrappers } from '../type-wrappers.mjs';
 
@@ -28,7 +27,7 @@ export const createPreferIsNonNullObject = ({
       fixable: 'code',
       schema: [],
       messages: {
-        useIsNonNullObject: `Replace the object/null check with \`isNonNullObject()\` from ${moduleName}.`,
+        useIsNonNullObject: `Replace the object/null check with \`{{isNonNullObject}}()\` from ${moduleName}.`,
       },
       defaultOptions: [],
     },
@@ -54,15 +53,21 @@ export const createPreferIsNonNullObject = ({
           );
         },
         'Program:exit': () => {
-          const binding = bindValueImports(sourceCode, moduleName, [
+          if (mut_pairsToFix.length === 0) {
+            return;
+          }
+
+          const bindingAt = bindValueImportsAt(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 binding = bindingAt(chain);
+
+            const localName = binding?.localNames[0];
+
             const loc = {
               start: sourceCode.getLocFromIndex(range[0]),
               end: sourceCode.getLocFromIndex(range[1]),
@@ -71,10 +76,12 @@ export const createPreferIsNonNullObject = ({
             context.report({
               loc,
               messageId: 'useIsNonNullObject',
+              data: {
+                // The name the fix writes; with no fix, the export's own.
+                isNonNullObject: localName ?? 'isNonNullObject',
+              },
               fix:
-                binding === undefined ||
-                localName === undefined ||
-                hasForeignBinding(sourceCode, chain, localName, moduleName)
+                binding === undefined || localName === undefined
                   ? null
                   : (fixer) => [
                       ...binding.edits(fixer),

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

@@ -4,8 +4,7 @@ import {
   type TSESTree,
 } from '@typescript-eslint/utils';
 import * as ts from 'typescript';
-import { hasForeignBinding } from '../bindings.mjs';
-import { bindValueImports } from '../imports.mjs';
+import { bindValueImportsAt } from '../imports.mjs';
 import { getArgumentText } from '../parentheses.mjs';
 import {
   isIdentifierNamed,
@@ -33,8 +32,8 @@ export const createPreferIsRecordAndHasKey = ({
       fixable: 'code',
       schema: [],
       messages: {
-        useIsRecordAndHasKey: `Replace \`{{original}}\` with \`isRecord({{objName}}) && hasKey({{objName}}, {{keyName}})\` from ${moduleName}.`,
-        useHasKey: `Replace \`{{original}}\` with \`hasKey({{objName}}, {{keyName}})\` from ${moduleName}.`,
+        useIsRecordAndHasKey: `Replace \`{{original}}\` with \`{{isRecord}}({{objName}}) && {{hasKey}}({{objName}}, {{keyName}})\` from ${moduleName}.`,
+        useHasKey: `Replace \`{{original}}\` with \`{{hasKey}}({{objName}}, {{keyName}})\` from ${moduleName}.`,
       },
       defaultOptions: [],
     },
@@ -152,14 +151,18 @@ export const createPreferIsRecordAndHasKey = ({
         },
 
         'Program:exit': () => {
+          if (mut_nodesToFix.length === 0) {
+            return;
+          }
+
           // 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, [
+          const withIsRecordAt = bindValueImportsAt(sourceCode, moduleName, [
             'isRecord',
             'hasKey',
           ]);
 
-          const hasKeyOnly = bindValueImports(sourceCode, moduleName, [
+          const hasKeyOnlyAt = bindValueImportsAt(sourceCode, moduleName, [
             'hasKey',
           ]);
 
@@ -168,7 +171,9 @@ export const createPreferIsRecordAndHasKey = ({
             // true, so it is left out of the replacement entirely.
             const needsIsRecord = !isKnownRecord(objExpression);
 
-            const binding = needsIsRecord ? withIsRecord : hasKeyOnly;
+            const binding = (needsIsRecord ? withIsRecordAt : hasKeyOnlyAt)(
+              node,
+            );
 
             const hasKeyName = binding?.localNames.at(-1);
 
@@ -185,11 +190,7 @@ export const createPreferIsRecordAndHasKey = ({
               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),
-              );
+              (!needsIsRecord || isSideEffectFree(objExpression));
 
             context.report({
               node,
@@ -198,6 +199,10 @@ export const createPreferIsRecordAndHasKey = ({
                 original: sourceCode.getText(node),
                 objName: objText,
                 keyName: keyText,
+                // The names a fix here writes; where none can bind them, the
+                // exports' own.
+                isRecord: isRecordName ?? 'isRecord',
+                hasKey: hasKeyName ?? 'hasKey',
               },
               fix: fixable
                 ? (fixer) => [

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

@@ -5,8 +5,7 @@ import {
 } from '@typescript-eslint/utils';
 import type { ReadonlyRecord } from 'ts-type-forge';
 import * as ts from 'typescript';
-import { hasForeignBinding } from '../bindings.mjs';
-import { bindValueImports } from '../imports.mjs';
+import { bindValueImportsAt } from '../imports.mjs';
 import { getArgumentText } from '../parentheses.mjs';
 import {
   isIdentifierNamed,
@@ -142,7 +141,7 @@ const createSafeParseRule = <MessageId extends string>(
       schema: [],
       messages: {
         ...messages,
-        replaceWithSafeParse: `Replace with \`Result.unwrapOkOr(${namespace}.${method}({{argName}}), Number.NaN)\`.`,
+        replaceWithSafeParse: `Replace with \`{{resultName}}.unwrapOkOr({{namespaceName}}.${method}({{argName}}), Number.NaN)\`.`,
       },
       defaultOptions: [],
     },
@@ -185,30 +184,39 @@ const createSafeParseRule = <MessageId extends string>(
           mut_reports.push({ node, argExpression: firstArg });
         },
         'Program:exit': () => {
-          const binding = bindValueImports(
+          if (mut_reports.length === 0) {
+            return;
+          }
+
+          const bindingAt = bindValueImportsAt(
             sourceCode,
             moduleName,
             requiredImports,
           );
 
-          const localNameOf = (name: string): string | undefined =>
-            binding?.localNames[requiredImports.indexOf(name)];
-
-          const namespaceName = localNameOf(namespace);
-
-          const resultName = localNameOf('Result');
-
           // A suggestion, never an autofix: the replacement parses some
           // strings differently (`parseInt('1e3')` is 1, the rewrite 1000;
           // `parseFloat('12px')` is 12, the rewrite NaN; `Number('')` is 0, the
           // rewrite NaN), so applying it is a person's decision. Each one
           // brings its names into scope itself, so that it is complete alone.
           for (const { node, argExpression } of mut_reports) {
+            const binding = bindingAt(node);
+
+            const localNameOf = (name: string): string | undefined =>
+              binding?.localNames[requiredImports.indexOf(name)];
+
+            const namespaceName = localNameOf(namespace);
+
+            const resultName = localNameOf('Result');
+
             const argText = getArgumentText(sourceCode, argExpression);
 
             const data = {
               original: sourceCode.getText(node),
               argName: argText,
+              // The names the suggestion writes; with none, the exports' own.
+              namespaceName: namespaceName ?? namespace,
+              resultName: resultName ?? 'Result',
             } as const;
 
             context.report({
@@ -218,10 +226,7 @@ const createSafeParseRule = <MessageId extends string>(
               suggest:
                 binding === undefined ||
                 namespaceName === undefined ||
-                resultName === undefined ||
-                [namespaceName, resultName].some((name) =>
-                  hasForeignBinding(sourceCode, node, name, moduleName),
-                )
+                resultName === undefined
                   ? []
                   : [
                       {
@@ -244,12 +249,12 @@ const createSafeParseRule = <MessageId extends string>(
   } as const;
 };
 
-const messageText = ({
-  moduleName,
-  namespace,
-  method,
-}: SafeParseRuleConfig): string =>
-  `Replace \`{{original}}\` with \`Result.unwrapOkOr(${namespace}.${method}({{argName}}), Number.NaN)\` from ${moduleName}. It parses some strings differently from the call it replaces, so check the input before applying it.` as const;
+/**
+ * The report's message. `{{namespaceName}}` and `{{resultName}}` are the names
+ * the suggestion writes.
+ */
+const messageText = ({ moduleName, method }: SafeParseRuleConfig): string =>
+  `Replace \`{{original}}\` with \`{{resultName}}.unwrapOkOr({{namespaceName}}.${method}({{argName}}), Number.NaN)\` from ${moduleName}. It parses some strings differently from the call it replaces, so check the input before applying it.` as const;
 
 /** Whether `callee` is the global function `name`, as in `parseInt(...)`. */
 const isGlobalCall = (callee: TSESTree.Expression, name: string): boolean =>