eslint-plugin-ts-data-forge 0.6.0 → 0.7.0

package/dist/rules/prefer-canonical-length-guard.mjs

@@ -1,4 +1,4 @@
-import { AST_NODE_TYPES } from '@typescript-eslint/utils';
+import { AST_NODE_TYPES, } from '@typescript-eslint/utils';
 import { getImportedLocalName, getTsDataForgeImport } from './import-utils.mjs';
 import { preferArrIsBoundedLengthArray } from './prefer-arr-is-bounded-length-array.mjs';
 import { preferArrIsFixedLengthArray } from './prefer-arr-is-fixed-length-array.mjs';
@@ -6,124 +6,175 @@ import { preferArrIsMaxLengthArray } from './prefer-arr-is-max-length-array.mjs'
 import { preferArrIsMinLengthArray } from './prefer-arr-is-min-length-array.mjs';
 import { preferArrIsNonEmpty } from './prefer-arr-is-non-empty.mjs';
 
+
+
+
+
+
+
+
+
 const COMPARISON_RULES = [
-  preferArrIsNonEmpty,
-  preferArrIsMinLengthArray,
-  preferArrIsMaxLengthArray,
-  preferArrIsBoundedLengthArray,
-  preferArrIsFixedLengthArray
+    preferArrIsNonEmpty,
+    preferArrIsMinLengthArray,
+    preferArrIsMaxLengthArray,
+    preferArrIsBoundedLengthArray,
+    preferArrIsFixedLengthArray,
 ];
 const MESSAGES = {
-  useCanonicalGuard: "Replace `{{arrName}}.{{guard}}({{boundsText}})` with `{{arrName}}.{{replacement}}(...)`: the bound makes the two guards equivalent.",
-  useIsNonEmpty: preferArrIsNonEmpty.meta.messages.useIsNonEmpty,
-  useIsMinLengthArray: preferArrIsMinLengthArray.meta.messages.useIsMinLengthArray,
-  useIsMaxLengthArray: preferArrIsMaxLengthArray.meta.messages.useIsMaxLengthArray,
-  useIsBoundedLengthArray: preferArrIsBoundedLengthArray.meta.messages.useIsBoundedLengthArray,
-  useIsFixedLengthArray: preferArrIsFixedLengthArray.meta.messages.useIsFixedLengthArray
+    useCanonicalGuard: 'Replace `{{arrName}}.{{guard}}({{boundsText}})` with `{{arrName}}.{{replacement}}(...)`: the bound makes the two guards equivalent.',
+    useIsNonEmpty: preferArrIsNonEmpty.meta.messages.useIsNonEmpty,
+    useIsMinLengthArray: preferArrIsMinLengthArray.meta.messages.useIsMinLengthArray,
+    useIsMaxLengthArray: preferArrIsMaxLengthArray.meta.messages.useIsMaxLengthArray,
+    useIsBoundedLengthArray: preferArrIsBoundedLengthArray.meta.messages.useIsBoundedLengthArray,
+    useIsFixedLengthArray: preferArrIsFixedLengthArray.meta.messages.useIsFixedLengthArray,
 };
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
 const GUARD_REWRITES = [
-  { guard: "isFixedLengthArray", bounds: [0], replacement: "isEmpty" },
-  { guard: "isMaxLengthArray", bounds: [0], replacement: "isEmpty" },
-  { guard: "isBoundedLengthArray", bounds: [0, 0], replacement: "isEmpty" },
-  { guard: "isMinLengthArray", bounds: [1], replacement: "isNonEmpty" },
-  { guard: "isFixedLengthTuple", bounds: [0], replacement: "isEmptyTuple" },
-  { guard: "isMaxLengthTuple", bounds: [0], replacement: "isEmptyTuple" },
-  {
-    guard: "isBoundedLengthTuple",
-    bounds: [0, 0],
-    replacement: "isEmptyTuple"
-  },
-  { guard: "isMinLengthTuple", bounds: [1], replacement: "isNonEmptyTuple" }
+    { guard: 'isFixedLengthArray', bounds: [0], replacement: 'isEmpty' },
+    { guard: 'isMaxLengthArray', bounds: [0], replacement: 'isEmpty' },
+    { guard: 'isBoundedLengthArray', bounds: [0, 0], replacement: 'isEmpty' },
+    { guard: 'isMinLengthArray', bounds: [1], replacement: 'isNonEmpty' },
+    { guard: 'isFixedLengthTuple', bounds: [0], replacement: 'isEmptyTuple' },
+    { guard: 'isMaxLengthTuple', bounds: [0], replacement: 'isEmptyTuple' },
+    {
+        guard: 'isBoundedLengthTuple',
+        bounds: [0, 0],
+        replacement: 'isEmptyTuple',
+    },
+    { guard: 'isMinLengthTuple', bounds: [1], replacement: 'isNonEmptyTuple' },
 ];
-const preferCanonicalLengthGuard = {
-  meta: {
-    type: "suggestion",
-    docs: {
-      description: "Normalize array-length checks to their canonical `Arr` guard: `xs.length <op> n` becomes the matching `Arr.is*` guard, and a degenerate guard becomes the named one for its family (`Arr.isFixedLengthArray(0, xs)` \u2192 `Arr.isEmpty`, `Arr.isFixedLengthTuple(0, xs)` \u2192 `Arr.isEmptyTuple`)."
+export const preferCanonicalLengthGuard = {
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Normalize array-length checks to their canonical `Arr` guard: `xs.length <op> n` becomes the matching `Arr.is*` guard, and a degenerate guard becomes the named one for its family (`Arr.isFixedLengthArray(0, xs)` → `Arr.isEmpty`, `Arr.isFixedLengthTuple(0, xs)` → `Arr.isEmptyTuple`).',
+        },
+        fixable: 'code',
+        schema: [],
+        messages: MESSAGES,
     },
-    fixable: "code",
-    schema: [],
-    messages: MESSAGES
-  },
-  create: (context) => {
-    const sourceCode = context.sourceCode;
-    const arrLocalName = getImportedLocalName(
-      getTsDataForgeImport(sourceCode.ast),
-      "Arr"
-    );
-    const comparisonVisitors = COMPARISON_RULES.map(
-      (rule) => rule.create(context)
-    );
-    if (arrLocalName === void 0) return mergeVisitors(comparisonVisitors);
-    return mergeVisitors([
-      ...comparisonVisitors,
-      {
-        CallExpression: (node) => {
-          const guardName = getGuardName(node, arrLocalName);
-          if (guardName === void 0) return;
-          const rewrite = GUARD_REWRITES.find(
-            (entry) => entry.guard === guardName
-          );
-          if (rewrite === void 0 || !matchesBounds(node, rewrite.bounds)) {
-            return;
-          }
-          const array = node.arguments[rewrite.bounds.length];
-          if (array === void 0) return;
-          const arrayText = sourceCode.getText(array);
-          context.report({
-            node,
-            messageId: "useCanonicalGuard",
-            data: {
-              arrName: arrLocalName,
-              guard: guardName,
-              boundsText: [...rewrite.bounds.map(String), "\u2026"].join(", "),
-              replacement: rewrite.replacement
+    create: (context) => {
+        const sourceCode = context.sourceCode;
+        const arrLocalName = getImportedLocalName(getTsDataForgeImport(sourceCode.ast), 'Arr');
+        const comparisonVisitors = COMPARISON_RULES.map((rule) => rule.create(context));
+        if (arrLocalName === undefined)
+            return mergeVisitors(comparisonVisitors);
+        return mergeVisitors([
+            ...comparisonVisitors,
+            {
+                CallExpression: (node) => {
+                    const guardName = getGuardName(node, arrLocalName);
+                    if (guardName === undefined)
+                        return;
+                    const rewrite = GUARD_REWRITES.find((entry) => entry.guard === guardName);
+                    if (rewrite === undefined || !matchesBounds(node, rewrite.bounds)) {
+                        return;
+                    }
+
+                    const array = node.arguments[rewrite.bounds.length];
+                    if (array === undefined)
+                        return;
+                    const arrayText = sourceCode.getText(array);
+                    context.report({
+                        node,
+                        messageId: 'useCanonicalGuard',
+                        data: {
+                            arrName: arrLocalName,
+                            guard: guardName,
+                            boundsText: [...rewrite.bounds.map(String), '…'].join(', '),
+                            replacement: rewrite.replacement,
+                        },
+                        fix: (fixer) => fixer.replaceText(node, `${arrLocalName}.${rewrite.replacement}(${arrayText})`),
+                    });
+                },
             },
-            fix: (fixer) => fixer.replaceText(
-              node,
-              `${arrLocalName}.${rewrite.replacement}(${arrayText})`
-            )
-          });
-        }
-      }
-    ]);
-  },
-  defaultOptions: []
+        ]);
+    },
+    defaultOptions: [],
 };
-const mergeVisitors = (visitors) => {
-  const mut_merged = {};
-  for (const visitor of visitors) {
-    for (const [selector, handler] of Object.entries(visitor)) {
-      if (typeof handler !== "function") continue;
-      const mut_handlers = mut_merged[selector] ?? [];
-      mut_handlers.push(handler);
-      mut_merged[selector] = mut_handlers;
-    }
-  }
-  return Object.fromEntries(
-    Object.entries(mut_merged).map(([selector, handlers]) => [
-      selector,
-      (node) => {
-        for (const handler of handlers) {
-          handler(node);
+
+
+
+
+const mergeVisitors = (
+
+
+
+visitors) => {
+    const mut_merged = {};
+    for (const visitor of visitors) {
+        for (const [selector, handler] of Object.entries(visitor)) {
+            if (typeof handler !== 'function')
+                continue;
+            const mut_handlers = mut_merged[selector] ?? [];
+            mut_handlers.push(handler);
+            mut_merged[selector] = mut_handlers;
         }
-      }
-    ])
-  );
-};
-const getGuardName = (node, arrLocalName) => {
-  const { callee } = node;
-  return callee.type === AST_NODE_TYPES.MemberExpression && !callee.computed && callee.object.type === AST_NODE_TYPES.Identifier && callee.object.name === arrLocalName && callee.property.type === AST_NODE_TYPES.Identifier ? callee.property.name : void 0;
+    }
+    return Object.fromEntries(Object.entries(mut_merged).map(([selector, handlers]) => [
+        selector,
+        (node) => {
+            for (const handler of handlers) {
+                handler(node);
+            }
+        },
+    ]));
 };
-const matchesBounds = (node, bounds) => {
-  const args = node.arguments;
-  if (args.length !== bounds.length + 1 || node.typeArguments !== void 0) {
-    return false;
-  }
-  return args.every(
-    (arg, index) => arg.type !== AST_NODE_TYPES.SpreadElement && (index === bounds.length || arg.type === AST_NODE_TYPES.Literal && arg.value === bounds[index])
-  );
+
+const getGuardName = (
+
+node, arrLocalName) => {
+    const { callee } = node;
+    return callee.type === AST_NODE_TYPES.MemberExpression &&
+        !callee.computed &&
+        callee.object.type === AST_NODE_TYPES.Identifier &&
+        callee.object.name === arrLocalName &&
+        callee.property.type === AST_NODE_TYPES.Identifier
+        ? callee.property.name
+        : undefined;
 };
 
-export { preferCanonicalLengthGuard };
-//# sourceMappingURL=prefer-canonical-length-guard.mjs.map
+
+
+
+
+
+
+const matchesBounds = (
+
+node, bounds) => {
+    const args = node.arguments;
+    if (args.length !== bounds.length + 1 || node.typeArguments !== undefined) {
+        return false;
+    }
+    return args.every((arg, index) => arg.type !== AST_NODE_TYPES.SpreadElement &&
+        (index === bounds.length ||
+            (arg.type === AST_NODE_TYPES.Literal && arg.value === bounds[index])));
+};
+//# sourceMappingURL=prefer-canonical-length-guard.mjs.map

package/dist/rules/prefer-canonical-length-guard.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"prefer-canonical-length-guard.mjs","sources":["../../src/rules/prefer-canonical-length-guard.mts"],"sourcesContent":["import {\n  AST_NODE_TYPES,\n  type TSESLint,\n  type TSESTree,\n} from '@typescript-eslint/utils';\nimport { type MutableRecord, type ReadonlyRecord } from 'ts-type-forge';\nimport { getImportedLocalName, getTsDataForgeImport } from './import-utils.mjs';\nimport { preferArrIsBoundedLengthArray } from './prefer-arr-is-bounded-length-array.mjs';\nimport { preferArrIsFixedLengthArray } from './prefer-arr-is-fixed-length-array.mjs';\nimport { preferArrIsMaxLengthArray } from './prefer-arr-is-max-length-array.mjs';\nimport { preferArrIsMinLengthArray } from './prefer-arr-is-min-length-array.mjs';\nimport { preferArrIsNonEmpty } from './prefer-arr-is-non-empty.mjs';\n\ntype Options = readonly [];\n\ntype MessageIds =\n  | 'useCanonicalGuard'\n  | 'useIsBoundedLengthArray'\n  | 'useIsFixedLengthArray'\n  | 'useIsMaxLengthArray'\n  | 'useIsMinLengthArray'\n  | 'useIsNonEmpty';\n\n/**\n * The `xs.length <op> n` → `Arr.is*` rules folded into this one.\n *\n * Their implementations are reused as-is rather than rewritten: this rule\n * merges their visitors, so every case they already cover (type-aware array\n * checks, `Arr` import insertion, the `&&`-bounded-range special case) keeps\n * behaving exactly as before, and their co-located tests keep exercising them\n * directly.\n */\nconst COMPARISON_RULES = [\n  preferArrIsNonEmpty,\n  preferArrIsMinLengthArray,\n  preferArrIsMaxLengthArray,\n  preferArrIsBoundedLengthArray,\n  preferArrIsFixedLengthArray,\n] as const;\n\nconst MESSAGES = {\n  useCanonicalGuard:\n    'Replace `{{arrName}}.{{guard}}({{boundsText}})` with `{{arrName}}.{{replacement}}(...)`: the bound makes the two guards equivalent.',\n  useIsNonEmpty: preferArrIsNonEmpty.meta.messages.useIsNonEmpty,\n  useIsMinLengthArray:\n    preferArrIsMinLengthArray.meta.messages.useIsMinLengthArray,\n  useIsMaxLengthArray:\n    preferArrIsMaxLengthArray.meta.messages.useIsMaxLengthArray,\n  useIsBoundedLengthArray:\n    preferArrIsBoundedLengthArray.meta.messages.useIsBoundedLengthArray,\n  useIsFixedLengthArray:\n    preferArrIsFixedLengthArray.meta.messages.useIsFixedLengthArray,\n} as const satisfies ReadonlyRecord<MessageIds, string>;\n\n/**\n * Length guards whose bound makes them redundant with a named degenerate\n * guard, keyed by guard name.\n *\n * Every entry stays inside its own family rather than crossing the\n * branded/structural divide:\n *\n * - the branded `*Array` guards go to `isEmpty` / `isNonEmpty`, which narrow to\n *   `FixedLengthArray<0, E> & Xs` / `MinLengthArray<1, E> & Xs`;\n * - the structural `*Tuple` guards go to `isEmptyTuple` / `isNonEmptyTuple`,\n *   which narrow to `readonly []` / `MinLengthTuple<1, E>`.\n *\n * Most entries are then **type-identical** — `isFixedLengthArray(0, xs)` and\n * `isMinLengthArray(1, xs)` produce exactly what `isEmpty` / `isNonEmpty`\n * narrow to, and `FixedLengthTuple<0, E>`, `MaxLengthTuple<0, E>` and\n * `BoundedLengthTuple<0, 0, E>` are all `readonly []`. Two *strengthen*:\n * `MaxLengthArray<0, E>` and `BoundedLengthArray<0, 0, E>` do not include the\n * `readonly []` structural part that `FixedLengthArray<0, E>` intersects on, so\n * rewriting them to `isEmpty` adds it. That is sound for a guard — the narrowed\n * type only flows outwards, and the stronger type is assignable everywhere the\n * old one was — and it stays within the branded family.\n *\n * Sending a `*Tuple` guard to the branded `isEmpty` would also be sound, but it\n * would silently change which family the value belongs to, which is why each\n * family keeps its own lane.\n */\nconst GUARD_REWRITES = [\n  { guard: 'isFixedLengthArray', bounds: [0], replacement: 'isEmpty' },\n  { guard: 'isMaxLengthArray', bounds: [0], replacement: 'isEmpty' },\n  { guard: 'isBoundedLengthArray', bounds: [0, 0], replacement: 'isEmpty' },\n  { guard: 'isMinLengthArray', bounds: [1], replacement: 'isNonEmpty' },\n  { guard: 'isFixedLengthTuple', bounds: [0], replacement: 'isEmptyTuple' },\n  { guard: 'isMaxLengthTuple', bounds: [0], replacement: 'isEmptyTuple' },\n  {\n    guard: 'isBoundedLengthTuple',\n    bounds: [0, 0],\n    replacement: 'isEmptyTuple',\n  },\n  { guard: 'isMinLengthTuple', bounds: [1], replacement: 'isNonEmptyTuple' },\n] as const satisfies readonly Readonly<{\n  guard: string;\n  bounds: readonly number[];\n  replacement: string;\n}>[];\n\nexport const preferCanonicalLengthGuard: TSESLint.RuleModule<\n  MessageIds,\n  Options\n> = {\n  meta: {\n    type: 'suggestion',\n    docs: {\n      description:\n        'Normalize array-length checks to their canonical `Arr` guard: `xs.length <op> n` becomes the matching `Arr.is*` guard, and a degenerate guard becomes the named one for its family (`Arr.isFixedLengthArray(0, xs)` → `Arr.isEmpty`, `Arr.isFixedLengthTuple(0, xs)` → `Arr.isEmptyTuple`).',\n    },\n    fixable: 'code',\n    schema: [],\n    messages: MESSAGES,\n  },\n\n  create: (context) => {\n    const sourceCode = context.sourceCode;\n\n    const arrLocalName = getImportedLocalName(\n      getTsDataForgeImport(sourceCode.ast),\n      'Arr',\n    );\n\n    const comparisonVisitors = COMPARISON_RULES.map((rule) =>\n      rule.create(context),\n    );\n\n    if (arrLocalName === undefined) return mergeVisitors(comparisonVisitors);\n\n    return mergeVisitors([\n      ...comparisonVisitors,\n      {\n        CallExpression: (node) => {\n          const guardName = getGuardName(node, arrLocalName);\n\n          if (guardName === undefined) return;\n\n          const rewrite = GUARD_REWRITES.find(\n            (entry) => entry.guard === guardName,\n          );\n\n          if (rewrite === undefined || !matchesBounds(node, rewrite.bounds)) {\n            return;\n          }\n\n          // The array is the last argument; the bounds precede it.\n          const array = node.arguments[rewrite.bounds.length];\n\n          if (array === undefined) return;\n\n          const arrayText = sourceCode.getText(array);\n\n          context.report({\n            node,\n            messageId: 'useCanonicalGuard',\n            data: {\n              arrName: arrLocalName,\n              guard: guardName,\n              boundsText: [...rewrite.bounds.map(String), '…'].join(', '),\n              replacement: rewrite.replacement,\n            },\n            fix: (fixer) =>\n              fixer.replaceText(\n                node,\n                `${arrLocalName}.${rewrite.replacement}(${arrayText})`,\n              ),\n          });\n        },\n      },\n    ]);\n  },\n  defaultOptions: [],\n} as const;\n\n/**\n * Combines several rule listeners into one, calling every handler registered\n * for a given selector in order.\n */\nconst mergeVisitors = (\n  // `RuleListener` holds mutable AST handler signatures, so it is not deeply\n  // readonly.\n  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types\n  visitors: readonly TSESLint.RuleListener[],\n): TSESLint.RuleListener => {\n  const mut_merged: MutableRecord<string, ((node: never) => void)[]> = {};\n\n  for (const visitor of visitors) {\n    for (const [selector, handler] of Object.entries(visitor)) {\n      if (typeof handler !== 'function') continue;\n\n      const mut_handlers = mut_merged[selector] ?? [];\n\n      mut_handlers.push(handler);\n\n      mut_merged[selector] = mut_handlers;\n    }\n  }\n\n  return Object.fromEntries(\n    Object.entries(mut_merged).map(([selector, handlers]) => [\n      selector,\n      (node: never) => {\n        for (const handler of handlers) {\n          handler(node);\n        }\n      },\n    ]),\n  );\n};\n\n/** The `Arr.<guard>` method name of `node`, or `undefined` for other calls. */\nconst getGuardName = (\n  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types\n  node: TSESTree.CallExpression,\n  arrLocalName: string,\n): string | undefined => {\n  const { callee } = node;\n\n  return callee.type === AST_NODE_TYPES.MemberExpression &&\n    !callee.computed &&\n    callee.object.type === AST_NODE_TYPES.Identifier &&\n    callee.object.name === arrLocalName &&\n    callee.property.type === AST_NODE_TYPES.Identifier\n    ? callee.property.name\n    : undefined;\n};\n\n/**\n * Whether the call is `guard(...bounds, array)` with every bound written as the\n * exact numeric literal the rewrite requires.\n *\n * The arity check also excludes the curried form (`guard(...bounds)`): the\n * degenerate guards take only the array, so there is nothing to rewrite it to.\n */\nconst matchesBounds = (\n  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types\n  node: TSESTree.CallExpression,\n  bounds: readonly number[],\n): boolean => {\n  const args = node.arguments;\n\n  if (args.length !== bounds.length + 1 || node.typeArguments !== undefined) {\n    return false;\n  }\n\n  return args.every(\n    (arg, index) =>\n      arg.type !== AST_NODE_TYPES.SpreadElement &&\n      (index === bounds.length ||\n        (arg.type === AST_NODE_TYPES.Literal && arg.value === bounds[index])),\n  );\n};\n"],"names":[],"mappings":"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"}
+{"version":3,"file":"prefer-canonical-length-guard.mjs","sourceRoot":"","sources":["../../src/rules/prefer-canonical-length-guard.mts"],"names":[],"mappings":"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"}

package/dist/rules/prefer-comparison-over-nullish-guard.mjs

@@ -1,80 +1,98 @@
-import { AST_NODE_TYPES } from '@typescript-eslint/utils';
+import { AST_NODE_TYPES, } from '@typescript-eslint/utils';
 import { buildCalleeResolver, getTsDataForgeImport } from './import-utils.mjs';
 
+
+
+
+
 const COMPARISON_GUARDS = {
-  isUndefined: { op: "===", literal: "undefined" },
-  isNotUndefined: { op: "!==", literal: "undefined" },
-  isNull: { op: "===", literal: "null" },
-  isNotNull: { op: "!==", literal: "null" }
+    isUndefined: { op: '===', literal: 'undefined' },
+    isNotUndefined: { op: '!==', literal: 'undefined' },
+    isNull: { op: '===', literal: 'null' },
+    isNotNull: { op: '!==', literal: 'null' },
 };
-const ARG_NEEDS_PARENS = /* @__PURE__ */ new Set([
-  AST_NODE_TYPES.LogicalExpression,
-  AST_NODE_TYPES.ConditionalExpression,
-  AST_NODE_TYPES.AssignmentExpression,
-  AST_NODE_TYPES.SequenceExpression,
-  AST_NODE_TYPES.ArrowFunctionExpression,
-  AST_NODE_TYPES.YieldExpression
+
+
+
+
+const ARG_NEEDS_PARENS = new Set([
+    AST_NODE_TYPES.LogicalExpression,
+    AST_NODE_TYPES.ConditionalExpression,
+    AST_NODE_TYPES.AssignmentExpression,
+    AST_NODE_TYPES.SequenceExpression,
+    AST_NODE_TYPES.ArrowFunctionExpression,
+    AST_NODE_TYPES.YieldExpression,
 ]);
+
+
+
+
 const needsWrappingInParent = (node) => {
-  const { parent } = node;
-  switch (parent.type) {
-    case AST_NODE_TYPES.UnaryExpression:
-    case AST_NODE_TYPES.AwaitExpression:
-    case AST_NODE_TYPES.BinaryExpression:
-    case AST_NODE_TYPES.TSNonNullExpression:
-      return true;
-    case AST_NODE_TYPES.MemberExpression:
-      return parent.object === node;
-    case AST_NODE_TYPES.CallExpression:
-    case AST_NODE_TYPES.NewExpression:
-      return parent.callee === node;
-    default:
-      return false;
-  }
+    const { parent } = node;
+
+
+    switch (parent.type) {
+        case AST_NODE_TYPES.UnaryExpression:
+        case AST_NODE_TYPES.AwaitExpression:
+        case AST_NODE_TYPES.BinaryExpression:
+        case AST_NODE_TYPES.TSNonNullExpression:
+            return true;
+        case AST_NODE_TYPES.MemberExpression:
+            return parent.object === node;
+        case AST_NODE_TYPES.CallExpression:
+        case AST_NODE_TYPES.NewExpression:
+            return parent.callee === node;
+        default:
+            return false;
+    }
 };
-const preferComparisonOverNullishGuard = {
-  meta: {
-    type: "suggestion",
-    docs: {
-      description: "Prefer a direct `=== null` / `!== undefined` comparison over calling `isNull`, `isNotNull`, `isUndefined`, or `isNotUndefined` with an explicit argument (those guards are intended for point-free use such as `xs.filter(isNotUndefined)`)."
+export const preferComparisonOverNullishGuard = {
+    meta: {
+        type: 'suggestion',
+        docs: {
+            description: 'Prefer a direct `=== null` / `!== undefined` comparison over calling `isNull`, `isNotNull`, `isUndefined`, or `isNotUndefined` with an explicit argument (those guards are intended for point-free use such as `xs.filter(isNotUndefined)`).',
+        },
+        fixable: 'code',
+        schema: [],
+        messages: {
+            preferComparison: 'Prefer `{{comparison}}` over calling `{{name}}` with an explicit argument.',
+        },
     },
-    fixable: "code",
-    schema: [],
-    messages: {
-      preferComparison: "Prefer `{{comparison}}` over calling `{{name}}` with an explicit argument."
-    }
-  },
-  create: (context) => {
-    const sourceCode = context.sourceCode;
-    const resolveGuard = buildCalleeResolver(
-      getTsDataForgeImport(sourceCode.ast)
-    );
-    return {
-      CallExpression: (node) => {
-        if (node.arguments.length !== 1) return;
-        const argument = node.arguments[0];
-        if (argument === void 0 || argument.type === AST_NODE_TYPES.SpreadElement) {
-          return;
-        }
-        const resolved = resolveGuard(node.callee);
-        if (resolved === void 0) return;
-        const spec = COMPARISON_GUARDS[resolved.canonicalName];
-        if (spec === void 0) return;
-        const argRaw = sourceCode.getText(argument);
-        const argText = ARG_NEEDS_PARENS.has(argument.type) ? `(${argRaw})` : argRaw;
-        const comparison = `${argText} ${spec.op} ${spec.literal}`;
-        const replacement = needsWrappingInParent(node) ? `(${comparison})` : comparison;
-        context.report({
-          node,
-          messageId: "preferComparison",
-          data: { comparison, name: resolved.canonicalName },
-          fix: (fixer) => fixer.replaceText(node, replacement)
-        });
-      }
-    };
-  },
-  defaultOptions: []
+    create: (context) => {
+        const sourceCode = context.sourceCode;
+        const resolveGuard = buildCalleeResolver(getTsDataForgeImport(sourceCode.ast));
+        return {
+            CallExpression: (node) => {
+                if (node.arguments.length !== 1)
+                    return;
+                const argument = node.arguments[0];
+                if (argument === undefined ||
+                    argument.type === AST_NODE_TYPES.SpreadElement) {
+                    return;
+                }
+                const resolved = resolveGuard(node.callee);
+                if (resolved === undefined)
+                    return;
+                const spec = COMPARISON_GUARDS[resolved.canonicalName];
+                if (spec === undefined)
+                    return;
+                const argRaw = sourceCode.getText(argument);
+                const argText = ARG_NEEDS_PARENS.has(argument.type)
+                    ? `(${argRaw})`
+                    : argRaw;
+                const comparison = `${argText} ${spec.op} ${spec.literal}`;
+                const replacement = needsWrappingInParent(node)
+                    ? `(${comparison})`
+                    : comparison;
+                context.report({
+                    node,
+                    messageId: 'preferComparison',
+                    data: { comparison, name: resolved.canonicalName },
+                    fix: (fixer) => fixer.replaceText(node, replacement),
+                });
+            },
+        };
+    },
+    defaultOptions: [],
 };
-
-export { preferComparisonOverNullishGuard };
-//# sourceMappingURL=prefer-comparison-over-nullish-guard.mjs.map
+//# sourceMappingURL=prefer-comparison-over-nullish-guard.mjs.map

package/dist/rules/prefer-comparison-over-nullish-guard.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"prefer-comparison-over-nullish-guard.mjs","sources":["../../src/rules/prefer-comparison-over-nullish-guard.mts"],"sourcesContent":["import {\n  AST_NODE_TYPES,\n  type TSESLint,\n  type TSESTree,\n} from '@typescript-eslint/utils';\nimport { type DeepReadonly, type ReadonlyRecord } from 'ts-type-forge';\nimport { buildCalleeResolver, getTsDataForgeImport } from './import-utils.mjs';\n\ntype Options = readonly [];\n\ntype MessageIds = 'preferComparison';\n\ntype ComparisonSpec = Readonly<{\n  op: '!==' | '===';\n  literal: 'null' | 'undefined';\n}>;\n\n/**\n * The nullish guards that are meant for point-free use (e.g.\n * `xs.filter(isNotUndefined)`). When called with an explicit argument a direct\n * comparison is clearer, so map each to its equivalent operator and literal.\n */\nconst COMPARISON_GUARDS: ReadonlyRecord<string, ComparisonSpec> = {\n  isUndefined: { op: '===', literal: 'undefined' },\n  isNotUndefined: { op: '!==', literal: 'undefined' },\n  isNull: { op: '===', literal: 'null' },\n  isNotNull: { op: '!==', literal: 'null' },\n} as const;\n\n/**\n * Argument expression kinds whose precedence is lower than equality, so they\n * must be parenthesized when placed on the left of `===` / `!==`.\n */\nconst ARG_NEEDS_PARENS: ReadonlySet<string> = new Set([\n  AST_NODE_TYPES.LogicalExpression,\n  AST_NODE_TYPES.ConditionalExpression,\n  AST_NODE_TYPES.AssignmentExpression,\n  AST_NODE_TYPES.SequenceExpression,\n  AST_NODE_TYPES.ArrowFunctionExpression,\n  AST_NODE_TYPES.YieldExpression,\n]);\n\n/**\n * Returns `true` when the comparison must be wrapped in parentheses to preserve\n * the original grouping given the call expression's parent context.\n */\nconst needsWrappingInParent = (\n  node: DeepReadonly<TSESTree.CallExpression>,\n): boolean => {\n  const { parent } = node;\n\n  // `parent.type` is one of 130+ AST kinds; only a handful need wrapping.\n  // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check\n  switch (parent.type) {\n    case AST_NODE_TYPES.UnaryExpression:\n    case AST_NODE_TYPES.AwaitExpression:\n    case AST_NODE_TYPES.BinaryExpression:\n    case AST_NODE_TYPES.TSNonNullExpression:\n      return true;\n\n    case AST_NODE_TYPES.MemberExpression:\n      return parent.object === node;\n\n    case AST_NODE_TYPES.CallExpression:\n    case AST_NODE_TYPES.NewExpression:\n      return parent.callee === node;\n\n    default:\n      return false;\n  }\n};\n\nexport const preferComparisonOverNullishGuard: TSESLint.RuleModule<\n  MessageIds,\n  Options\n> = {\n  meta: {\n    type: 'suggestion',\n    docs: {\n      description:\n        'Prefer a direct `=== null` / `!== undefined` comparison over calling `isNull`, `isNotNull`, `isUndefined`, or `isNotUndefined` with an explicit argument (those guards are intended for point-free use such as `xs.filter(isNotUndefined)`).',\n    },\n    fixable: 'code',\n    schema: [],\n    messages: {\n      preferComparison:\n        'Prefer `{{comparison}}` over calling `{{name}}` with an explicit argument.',\n    },\n  },\n\n  create: (context) => {\n    const sourceCode = context.sourceCode;\n\n    const resolveGuard = buildCalleeResolver(\n      getTsDataForgeImport(sourceCode.ast),\n    );\n\n    return {\n      CallExpression: (node) => {\n        if (node.arguments.length !== 1) return;\n\n        const argument = node.arguments[0];\n\n        if (\n          argument === undefined ||\n          argument.type === AST_NODE_TYPES.SpreadElement\n        ) {\n          return;\n        }\n\n        const resolved = resolveGuard(node.callee);\n\n        if (resolved === undefined) return;\n\n        const spec = COMPARISON_GUARDS[resolved.canonicalName];\n\n        if (spec === undefined) return;\n\n        const argRaw = sourceCode.getText(argument);\n\n        const argText = ARG_NEEDS_PARENS.has(argument.type)\n          ? `(${argRaw})`\n          : argRaw;\n\n        const comparison = `${argText} ${spec.op} ${spec.literal}`;\n\n        const replacement = needsWrappingInParent(node)\n          ? `(${comparison})`\n          : comparison;\n\n        context.report({\n          node,\n          messageId: 'preferComparison',\n          data: { comparison, name: resolved.canonicalName },\n          fix: (fixer) => fixer.replaceText(node, replacement),\n        });\n      },\n    };\n  },\n  defaultOptions: [],\n} as const;\n"],"names":[],"mappings":"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"}
+{"version":3,"file":"prefer-comparison-over-nullish-guard.mjs","sourceRoot":"","sources":["../../src/rules/prefer-comparison-over-nullish-guard.mts"],"names":[],"mappings":"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"}