eslint-plugin-ts-data-forge 0.3.0 → 0.4.1

package/dist/plugin.d.mts

@@ -12,7 +12,7 @@ export declare const eslintPluginTsDataForge: {
         readonly 'prefer-as-int': import("@typescript-eslint/utils/ts-eslint").RuleModule<"useBrandedNumberCastFunction", readonly [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         readonly 'prefer-is-non-null-object': import("@typescript-eslint/utils/ts-eslint").RuleModule<"useIsNonNullObject", readonly [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         readonly 'prefer-range-for-loop': import("@typescript-eslint/utils/ts-eslint").RuleModule<"useRangeForLoop", readonly [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
-        readonly 'prefer-is-record-and-has-key': import("@typescript-eslint/utils/ts-eslint").RuleModule<"useIsRecordAndHasKey", readonly [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+        readonly 'prefer-is-record-and-has-key': import("@typescript-eslint/utils/ts-eslint").RuleModule<"useHasKey" | "useIsRecordAndHasKey", readonly [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         readonly 'prefer-num-safe-parse-int': import("@typescript-eslint/utils/ts-eslint").RuleModule<"useSafeParseInt", readonly [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         readonly 'prefer-num-safe-parse-float': import("@typescript-eslint/utils/ts-eslint").RuleModule<"useSafeParseFloat", readonly [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
         readonly 'no-unnecessary-type-guard': import("@typescript-eslint/utils/ts-eslint").RuleModule<"alwaysFalse" | "alwaysTrue" | "replaceTypeGuard", readonly [(Readonly<{

package/dist/rules/no-unnecessary-type-guard.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"no-unnecessary-type-guard.d.mts","sourceRoot":"","sources":["../../src/rules/no-unnecessary-type-guard.mts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,QAAQ,EAEd,MAAM,0BAA0B,CAAC;AAUlC,KAAK,OAAO,GAAG,SAAS;IACtB,QAAQ,CAAC;QACP,+DAA+D;QAC/D,MAAM,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;KAC5B,CAAC,CAAC;CACJ,CAAC;AAEF,KAAK,UAAU,GAAG,YAAY,GAAG,aAAa,GAAG,kBAAkB,CAAC;AAyFpE,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,UAAU,CAAC,UAAU,EAAE,OAAO,CAoRhE,CAAC"}
+{"version":3,"file":"no-unnecessary-type-guard.d.mts","sourceRoot":"","sources":["../../src/rules/no-unnecessary-type-guard.mts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,QAAQ,EAEd,MAAM,0BAA0B,CAAC;AAUlC,KAAK,OAAO,GAAG,SAAS;IACtB,QAAQ,CAAC;QACP,+DAA+D;QAC/D,MAAM,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;KAC5B,CAAC,CAAC;CACJ,CAAC;AAEF,KAAK,UAAU,GAAG,YAAY,GAAG,aAAa,GAAG,kBAAkB,CAAC;AA2FpE,eAAO,MAAM,sBAAsB,EAAE,QAAQ,CAAC,UAAU,CAAC,UAAU,EAAE,OAAO,CAkShE,CAAC"}

package/dist/rules/no-unnecessary-type-guard.mjs

@@ -37,7 +37,8 @@ const GUARD_SPECS = {
     atoms: ["null", "undefined"],
     replacements: NULLISH_REPLACEMENTS_EXCLUDE
   },
-  isNonEmptyString: { kind: "nonEmptyString" }
+  isNonEmptyString: { kind: "nonEmptyString" },
+  isRecord: { kind: "record" }
 };
 const DEFERRED_OR_OPAQUE_FLAGS = ts.TypeFlags.Any | ts.TypeFlags.Unknown | ts.TypeFlags.Never | ts.TypeFlags.TypeParameter | ts.TypeFlags.IndexedAccess | ts.TypeFlags.Conditional | ts.TypeFlags.Substitution;
 const noUnnecessaryTypeGuard = {
@@ -182,6 +183,14 @@ const noUnnecessaryTypeGuard = {
             }
             break;
           }
+          case "record": {
+            if (parts.every((p) => isGuaranteedRecord(p, checker))) {
+              reportConstant(node, canonicalName, true, argument);
+            } else if (parts.every((p) => isGuaranteedNotRecord(p, checker))) {
+              reportConstant(node, canonicalName, false, argument);
+            }
+            break;
+          }
           case "nonEmptyString": {
             const hasNullish = inputAtoms.has("undefined") || inputAtoms.has("null");
             const nonNullishParts = parts.filter((p) => {
@@ -223,6 +232,9 @@ const collectUnionParts = (type) => {
   }
   return parts;
 };
+const isGuaranteedRecord = (type, checker) => checker.getIndexInfoOfType(type, ts.IndexKind.String) !== void 0 && !isCallableType(type, checker) && !checker.isArrayType(type) && !checker.isTupleType(type);
+const isGuaranteedNotRecord = (type, checker) => classifyAtom(type) !== "other" || checker.isArrayType(type) || checker.isTupleType(type) || isCallableType(type, checker);
+const isCallableType = (type, checker) => checker.getSignaturesOfType(type, ts.SignatureKind.Call).length > 0 || checker.getSignaturesOfType(type, ts.SignatureKind.Construct).length > 0;
 const classifyAtom = (type) => {
   const { flags } = type;
   if ((flags & ts.TypeFlags.Undefined) !== 0) return "undefined";

package/dist/rules/no-unnecessary-type-guard.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"no-unnecessary-type-guard.mjs","sources":["../../src/rules/no-unnecessary-type-guard.mts"],"sourcesContent":["import {\n  AST_NODE_TYPES,\n  ESLintUtils,\n  type TSESLint,\n  type TSESTree,\n} from '@typescript-eslint/utils';\nimport { type DeepReadonly } from 'ts-type-forge';\nimport * as ts from 'typescript';\nimport {\n  buildCalleeResolver,\n  buildImportFixes,\n  getImportedLocalName,\n  getTsDataForgeImport,\n} from './import-utils.mjs';\n\ntype Options = readonly [\n  Readonly<{\n    /** Names of ts-data-forge guard functions to skip checking. */\n    ignore?: readonly string[];\n  }>?,\n];\n\ntype MessageIds = 'alwaysTrue' | 'alwaysFalse' | 'replaceTypeGuard';\n\n/**\n * The primitive categories a (non-`null`/`undefined`) union member can fall\n * into. `other` covers anything the rule does not reason about (objects,\n * functions, `void`, …).\n */\ntype AtomKey =\n  'undefined' | 'null' | 'boolean' | 'number' | 'string' | 'bigint' | 'symbol';\n\ntype Atom = AtomKey | 'other';\n\ntype GuardSpec = DeepReadonly<\n  | {\n      kind: 'narrowTo';\n      atoms: AtomKey[];\n      replacements?: Record<string, string>;\n    }\n  | {\n      kind: 'excludeFrom';\n      atoms: AtomKey[];\n      replacements?: Record<string, string>;\n    }\n  | { kind: 'nonEmptyString' }\n>;\n\n/**\n * Internal marker property attached to every `ts-type-forge` branded type. Its\n * presence (together with the `MinLength` brand key) lets us recognize a\n * `NonEmptyString` without holding a reference to the type itself.\n */\nconst BRAND_MARKER_PROPERTY =\n  'TSTypeForgeInternals--edd2f9ce-7ca5-45b0-9d1a-bd61b9b5d9c3';\n\n/**\n * Brand key carried by `MinLengthString<N>` — and therefore by\n * `NonEmptyString = MinLengthString<1>`. Its value is `MinLengthTuple<N, 0>`, a\n * tuple of `0`s with at least `N` elements, so a required first element means\n * `N >= 1` (the string cannot be empty).\n */\nconst MIN_LENGTH_BRAND_KEY = 'MinLength';\n\nconst NULLISH_REPLACEMENTS_EXCLUDE: Readonly<Record<string, string>> = {\n  undefined: 'isNotUndefined',\n  null: 'isNotNull',\n} as const;\n\nconst NULLISH_REPLACEMENTS_NARROW: Readonly<Record<string, string>> = {\n  undefined: 'isUndefined',\n  null: 'isNull',\n} as const;\n\nconst GUARD_SPECS: DeepReadonly<Record<string, GuardSpec>> = {\n  isUndefined: { kind: 'narrowTo', atoms: ['undefined'] },\n  isNotUndefined: { kind: 'excludeFrom', atoms: ['undefined'] },\n  isNull: { kind: 'narrowTo', atoms: ['null'] },\n  isNotNull: { kind: 'excludeFrom', atoms: ['null'] },\n  isBoolean: { kind: 'narrowTo', atoms: ['boolean'] },\n  isNotBoolean: { kind: 'excludeFrom', atoms: ['boolean'] },\n  isNumber: { kind: 'narrowTo', atoms: ['number'] },\n  isNotNumber: { kind: 'excludeFrom', atoms: ['number'] },\n  isString: { kind: 'narrowTo', atoms: ['string'] },\n  isNotString: { kind: 'excludeFrom', atoms: ['string'] },\n  isBigint: { kind: 'narrowTo', atoms: ['bigint'] },\n  isNotBigint: { kind: 'excludeFrom', atoms: ['bigint'] },\n  isSymbol: { kind: 'narrowTo', atoms: ['symbol'] },\n  isNotSymbol: { kind: 'excludeFrom', atoms: ['symbol'] },\n  isNullish: {\n    kind: 'narrowTo',\n    atoms: ['null', 'undefined'],\n    replacements: NULLISH_REPLACEMENTS_NARROW,\n  },\n  isNonNullish: {\n    kind: 'excludeFrom',\n    atoms: ['null', 'undefined'],\n    replacements: NULLISH_REPLACEMENTS_EXCLUDE,\n  },\n  isNonEmptyString: { kind: 'nonEmptyString' },\n} as const;\n\nconst DEFERRED_OR_OPAQUE_FLAGS =\n  ts.TypeFlags.Any |\n  ts.TypeFlags.Unknown |\n  ts.TypeFlags.Never |\n  ts.TypeFlags.TypeParameter |\n  ts.TypeFlags.IndexedAccess |\n  ts.TypeFlags.Conditional |\n  ts.TypeFlags.Substitution;\n\nexport const noUnnecessaryTypeGuard: TSESLint.RuleModule<MessageIds, Options> =\n  {\n    meta: {\n      type: 'suggestion',\n      docs: {\n        description:\n          'Detect ts-data-forge type guard calls that perform no narrowing (the argument type already satisfies, or can never satisfy, the guard).',\n      },\n      fixable: 'code',\n      schema: [\n        {\n          type: 'object',\n          properties: {\n            ignore: {\n              type: 'array',\n              items: { type: 'string' },\n              description:\n                'Names of ts-data-forge guard functions to skip checking.',\n            },\n          },\n          additionalProperties: false,\n        },\n      ],\n      messages: {\n        alwaysTrue:\n          'Unnecessary `{{name}}` call: the argument type guarantees it always returns `true`. Replace the call with `true`.',\n        alwaysFalse:\n          'Unnecessary `{{name}}` call: the argument type guarantees it always returns `false`. Replace the call with `false`.',\n        replaceTypeGuard:\n          'Unnecessary `{{from}}` call: the argument can only be narrowed by `{{to}}`. Use `{{to}}` instead.',\n      },\n    },\n\n    create: (context) => {\n      const options = context.options[0];\n\n      const parserServices = ESLintUtils.getParserServices(context);\n\n      const compilerOptions = parserServices.program.getCompilerOptions();\n\n      // Without `strictNullChecks`, `null` / `undefined` are erased from the type\n      // system, so reasoning about nullish narrowing is unsound. Disable entirely.\n      const strictNullChecks =\n        compilerOptions.strictNullChecks ?? compilerOptions.strict ?? false;\n\n      if (!strictNullChecks) return {};\n\n      const checker = parserServices.program.getTypeChecker();\n\n      const sourceCode = context.sourceCode;\n\n      const program = sourceCode.ast;\n\n      const ignored = new Set(options?.ignore);\n\n      const tsDataForgeImport = getTsDataForgeImport(program);\n\n      const resolveGuard = buildCalleeResolver(tsDataForgeImport);\n\n      const buildReplaceFix =\n        (\n          isNamespace: boolean,\n          // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types\n          propertyNode: TSESTree.Node,\n          replacement: string,\n        ): TSESLint.ReportFixFunction =>\n        (fixer) => {\n          // A namespace member access (`tf.isX`) exposes every export, so the\n          // canonical name is always in scope.\n          if (isNamespace) {\n            return [fixer.replaceText(propertyNode, replacement)];\n          }\n\n          // If the replacement guard is already imported (possibly under an\n          // alias), rename to its in-scope local name. Otherwise add a new\n          // import and rename to the canonical name.\n          const localName = getImportedLocalName(\n            tsDataForgeImport,\n            replacement,\n          );\n\n          if (localName !== undefined) {\n            return [fixer.replaceText(propertyNode, localName)];\n          }\n\n          return [\n            ...buildImportFixes(fixer, program, tsDataForgeImport, [\n              replacement,\n            ]),\n            fixer.replaceText(propertyNode, replacement),\n          ];\n        };\n\n      const reportConstant = (\n        node: DeepReadonly<TSESTree.CallExpression>,\n        name: string,\n        value: boolean,\n        argument: DeepReadonly<TSESTree.Expression>,\n      ): void => {\n        // Replacing the call with a literal drops the argument expression, so only\n        // autofix when evaluating it cannot have observable side effects.\n        const canFix = isSideEffectFreeArg(argument);\n\n        context.report({\n          // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n          node: node as TSESTree.Node,\n          messageId: value ? 'alwaysTrue' : 'alwaysFalse',\n          data: { name },\n          fix: canFix\n            ? (fixer) =>\n                fixer.replaceText(\n                  // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n                  node as TSESTree.Node,\n                  value ? 'true' : 'false',\n                )\n            : undefined,\n        });\n      };\n\n      const reportReplace = (\n        node: DeepReadonly<TSESTree.CallExpression>,\n        from: string,\n        to: string,\n        isNamespace: boolean,\n        // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types\n        propertyNode: TSESTree.Node,\n      ): void => {\n        context.report({\n          // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n          node: node as TSESTree.Node,\n          messageId: 'replaceTypeGuard',\n          data: { from, to },\n          fix: buildReplaceFix(isNamespace, propertyNode, to),\n        });\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 { canonicalName, propertyNode, isNamespace } = resolved;\n\n          if (ignored.has(canonicalName)) return;\n\n          const spec = GUARD_SPECS[canonicalName];\n\n          if (spec === undefined) return;\n\n          const argTsNode = parserServices.esTreeNodeToTSNodeMap.get(argument);\n\n          const argType = checker.getTypeAtLocation(argTsNode);\n\n          const parts = collectUnionParts(argType);\n\n          if (parts === undefined) return; // opaque / generic → bail conservatively\n\n          const inputAtoms = new Set(parts.map(classifyAtom));\n\n          const hasMemberOutsideTarget = (\n            atoms: readonly AtomKey[],\n          ): boolean => {\n            const targetSet = new Set<Atom>(atoms);\n\n            return parts.some((p) => !targetSet.has(classifyAtom(p)));\n          };\n\n          switch (spec.kind) {\n            case 'excludeFrom': {\n              const removable = spec.atoms.filter((a) => inputAtoms.has(a));\n\n              if (removable.length === 0) {\n                // Nothing to exclude → the guard always holds.\n                reportConstant(node, canonicalName, true, argument);\n              } else if (!hasMemberOutsideTarget(spec.atoms)) {\n                // Every member is excluded → the guard never holds.\n                reportConstant(node, canonicalName, false, argument);\n              } else if (removable.length < spec.atoms.length) {\n                const replacement = spec.replacements?.[joinAtoms(removable)];\n\n                if (replacement !== undefined) {\n                  reportReplace(\n                    node,\n                    canonicalName,\n                    replacement,\n                    isNamespace,\n                    propertyNode,\n                  );\n                }\n              }\n\n              break;\n            }\n\n            case 'narrowTo': {\n              const present = spec.atoms.filter((a) => inputAtoms.has(a));\n\n              if (present.length === 0) {\n                // No member is in the target set → the guard never holds.\n                reportConstant(node, canonicalName, false, argument);\n              } else if (!hasMemberOutsideTarget(spec.atoms)) {\n                // Input ⊆ target → the guard always holds and narrows nothing.\n                reportConstant(node, canonicalName, true, argument);\n              } else if (present.length < spec.atoms.length) {\n                const replacement = spec.replacements?.[joinAtoms(present)];\n\n                if (replacement !== undefined) {\n                  reportReplace(\n                    node,\n                    canonicalName,\n                    replacement,\n                    isNamespace,\n                    propertyNode,\n                  );\n                }\n              }\n\n              break;\n            }\n\n            case 'nonEmptyString': {\n              const hasNullish =\n                inputAtoms.has('undefined') || inputAtoms.has('null');\n\n              const nonNullishParts = parts.filter((p) => {\n                const atom = classifyAtom(p);\n\n                return atom !== 'undefined' && atom !== 'null';\n              });\n\n              if (!nonNullishParts.some(couldBeNonEmptyString)) {\n                // No member can be a non-empty string → the guard never holds.\n                reportConstant(node, canonicalName, false, argument);\n\n                break;\n              }\n\n              if (\n                nonNullishParts.some(\n                  (p) => !isGuaranteedNonEmptyString(p, checker),\n                )\n              ) {\n                break; // still does real string/empty work\n              }\n\n              if (hasNullish) {\n                reportReplace(\n                  node,\n                  canonicalName,\n                  'isNonNullish',\n                  isNamespace,\n                  propertyNode,\n                );\n              } else {\n                reportConstant(node, canonicalName, true, argument);\n              }\n\n              break;\n            }\n          }\n        },\n      };\n    },\n    defaultOptions: [{}],\n  } as const;\n\n/**\n * Decomposes a type into its union members. Returns `undefined` when any member\n * is opaque (`any` / `unknown` / `never`) or deferred (type parameter, indexed\n * access, …), signalling that the rule should not draw conclusions.\n */\n// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types\nconst collectUnionParts = (type: ts.Type): readonly ts.Type[] | undefined => {\n  const parts = type.isUnion() ? type.types : ([type] as const);\n\n  for (const part of parts) {\n    if ((part.flags & DEFERRED_OR_OPAQUE_FLAGS) !== 0) return undefined;\n  }\n\n  return parts;\n};\n\n/** Classifies a single (non-union) type into a primitive {@link Atom}. */\n// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types\nconst classifyAtom = (type: ts.Type): Atom => {\n  const { flags } = type;\n\n  if ((flags & ts.TypeFlags.Undefined) !== 0) return 'undefined';\n\n  if ((flags & ts.TypeFlags.Null) !== 0) return 'null';\n\n  if ((flags & ts.TypeFlags.BooleanLike) !== 0) return 'boolean';\n\n  if ((flags & ts.TypeFlags.NumberLike) !== 0) return 'number';\n\n  if ((flags & ts.TypeFlags.StringLike) !== 0) return 'string';\n\n  if ((flags & ts.TypeFlags.BigIntLike) !== 0) return 'bigint';\n\n  if ((flags & ts.TypeFlags.ESSymbolLike) !== 0) return 'symbol';\n\n  // Branded primitives (e.g. `NonEmptyString = string & {...}`) are\n  // intersections; classify them by their underlying primitive constituent.\n  if (type.isIntersection()) {\n    for (const constituent of type.types) {\n      const atom = classifyAtom(constituent);\n\n      if (atom !== 'other') return atom;\n    }\n  }\n\n  return 'other';\n};\n\nconst ATOM_ORDER: readonly AtomKey[] = [\n  'undefined',\n  'null',\n  'boolean',\n  'number',\n  'string',\n  'bigint',\n  'symbol',\n] as const;\n\n/** A stable key for a set of atoms, used to look up replacement guards. */\nconst joinAtoms = (atoms: readonly AtomKey[]): string =>\n  ATOM_ORDER.filter((atom) => atoms.includes(atom)).join('|');\n\n/**\n * Returns `true` when the type is guaranteed to be a non-empty string: either a\n * non-empty string literal or a value branded as `NonEmptyString`\n * (`MinLengthString<N>` with `N >= 1`).\n */\nconst isGuaranteedNonEmptyString = (\n  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types\n  type: ts.Type,\n  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types\n  checker: ts.TypeChecker,\n): boolean => {\n  if (type.isStringLiteral()) return type.value !== '';\n\n  if (type.getProperty(BRAND_MARKER_PROPERTY) === undefined) return false;\n\n  const minLengthSymbol = type.getProperty(MIN_LENGTH_BRAND_KEY);\n\n  if (minLengthSymbol === undefined) return false;\n\n  // The `MinLength` brand value is `MinLengthTuple<N, 0>`; it has a required\n  // first element (`'0'`) exactly when `N >= 1`, i.e. the string is non-empty.\n  // `MinLengthString<0>` brands with a plain array and has no such element.\n  return (\n    checker.getTypeOfSymbol(minLengthSymbol).getProperty('0') !== undefined\n  );\n};\n\n/**\n * Returns `true` when the type can possibly be a non-empty string (a general\n * `string`, a branded string, or a non-empty string literal). The empty string\n * literal and non-string types cannot.\n */\n// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types\nconst couldBeNonEmptyString = (type: ts.Type): boolean => {\n  if (type.isStringLiteral()) return type.value !== '';\n\n  return classifyAtom(type) === 'string';\n};\n\n/**\n * Returns `true` when evaluating the expression cannot have observable side\n * effects, so replacing the surrounding call with a literal is safe. Limited to\n * simple references (identifiers, `this`, literals, and member-access chains).\n */\n\nconst isSideEffectFreeArg = (node: DeepReadonly<TSESTree.Node>): boolean => {\n  // `node.type` is one of 130+ AST kinds; only a handful are relevant here.\n  // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check\n  switch (node.type) {\n    case AST_NODE_TYPES.Identifier:\n    case AST_NODE_TYPES.ThisExpression:\n    case AST_NODE_TYPES.Literal:\n      return true;\n\n    case AST_NODE_TYPES.MemberExpression:\n      return (\n        isSideEffectFreeArg(node.object) &&\n        (!node.computed || isSideEffectFreeArg(node.property))\n      );\n\n    default:\n      return false;\n  }\n};\n"],"names":[],"mappings":"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"}
+{"version":3,"file":"no-unnecessary-type-guard.mjs","sources":["../../src/rules/no-unnecessary-type-guard.mts"],"sourcesContent":["import {\n  AST_NODE_TYPES,\n  ESLintUtils,\n  type TSESLint,\n  type TSESTree,\n} from '@typescript-eslint/utils';\nimport { type DeepReadonly } from 'ts-type-forge';\nimport * as ts from 'typescript';\nimport {\n  buildCalleeResolver,\n  buildImportFixes,\n  getImportedLocalName,\n  getTsDataForgeImport,\n} from './import-utils.mjs';\n\ntype Options = readonly [\n  Readonly<{\n    /** Names of ts-data-forge guard functions to skip checking. */\n    ignore?: readonly string[];\n  }>?,\n];\n\ntype MessageIds = 'alwaysTrue' | 'alwaysFalse' | 'replaceTypeGuard';\n\n/**\n * The primitive categories a (non-`null`/`undefined`) union member can fall\n * into. `other` covers anything the rule does not reason about (objects,\n * functions, `void`, …).\n */\ntype AtomKey =\n  'undefined' | 'null' | 'boolean' | 'number' | 'string' | 'bigint' | 'symbol';\n\ntype Atom = AtomKey | 'other';\n\ntype GuardSpec = DeepReadonly<\n  | {\n      kind: 'narrowTo';\n      atoms: AtomKey[];\n      replacements?: Record<string, string>;\n    }\n  | {\n      kind: 'excludeFrom';\n      atoms: AtomKey[];\n      replacements?: Record<string, string>;\n    }\n  | { kind: 'nonEmptyString' }\n  | { kind: 'record' }\n>;\n\n/**\n * Internal marker property attached to every `ts-type-forge` branded type. Its\n * presence (together with the `MinLength` brand key) lets us recognize a\n * `NonEmptyString` without holding a reference to the type itself.\n */\nconst BRAND_MARKER_PROPERTY =\n  'TSTypeForgeInternals--edd2f9ce-7ca5-45b0-9d1a-bd61b9b5d9c3';\n\n/**\n * Brand key carried by `MinLengthString<N>` — and therefore by\n * `NonEmptyString = MinLengthString<1>`. Its value is `MinLengthTuple<N, 0>`, a\n * tuple of `0`s with at least `N` elements, so a required first element means\n * `N >= 1` (the string cannot be empty).\n */\nconst MIN_LENGTH_BRAND_KEY = 'MinLength';\n\nconst NULLISH_REPLACEMENTS_EXCLUDE: Readonly<Record<string, string>> = {\n  undefined: 'isNotUndefined',\n  null: 'isNotNull',\n} as const;\n\nconst NULLISH_REPLACEMENTS_NARROW: Readonly<Record<string, string>> = {\n  undefined: 'isUndefined',\n  null: 'isNull',\n} as const;\n\nconst GUARD_SPECS: DeepReadonly<Record<string, GuardSpec>> = {\n  isUndefined: { kind: 'narrowTo', atoms: ['undefined'] },\n  isNotUndefined: { kind: 'excludeFrom', atoms: ['undefined'] },\n  isNull: { kind: 'narrowTo', atoms: ['null'] },\n  isNotNull: { kind: 'excludeFrom', atoms: ['null'] },\n  isBoolean: { kind: 'narrowTo', atoms: ['boolean'] },\n  isNotBoolean: { kind: 'excludeFrom', atoms: ['boolean'] },\n  isNumber: { kind: 'narrowTo', atoms: ['number'] },\n  isNotNumber: { kind: 'excludeFrom', atoms: ['number'] },\n  isString: { kind: 'narrowTo', atoms: ['string'] },\n  isNotString: { kind: 'excludeFrom', atoms: ['string'] },\n  isBigint: { kind: 'narrowTo', atoms: ['bigint'] },\n  isNotBigint: { kind: 'excludeFrom', atoms: ['bigint'] },\n  isSymbol: { kind: 'narrowTo', atoms: ['symbol'] },\n  isNotSymbol: { kind: 'excludeFrom', atoms: ['symbol'] },\n  isNullish: {\n    kind: 'narrowTo',\n    atoms: ['null', 'undefined'],\n    replacements: NULLISH_REPLACEMENTS_NARROW,\n  },\n  isNonNullish: {\n    kind: 'excludeFrom',\n    atoms: ['null', 'undefined'],\n    replacements: NULLISH_REPLACEMENTS_EXCLUDE,\n  },\n  isNonEmptyString: { kind: 'nonEmptyString' },\n  isRecord: { kind: 'record' },\n} as const;\n\nconst DEFERRED_OR_OPAQUE_FLAGS =\n  ts.TypeFlags.Any |\n  ts.TypeFlags.Unknown |\n  ts.TypeFlags.Never |\n  ts.TypeFlags.TypeParameter |\n  ts.TypeFlags.IndexedAccess |\n  ts.TypeFlags.Conditional |\n  ts.TypeFlags.Substitution;\n\nexport const noUnnecessaryTypeGuard: TSESLint.RuleModule<MessageIds, Options> =\n  {\n    meta: {\n      type: 'suggestion',\n      docs: {\n        description:\n          'Detect ts-data-forge type guard calls that perform no narrowing (the argument type already satisfies, or can never satisfy, the guard).',\n      },\n      fixable: 'code',\n      schema: [\n        {\n          type: 'object',\n          properties: {\n            ignore: {\n              type: 'array',\n              items: { type: 'string' },\n              description:\n                'Names of ts-data-forge guard functions to skip checking.',\n            },\n          },\n          additionalProperties: false,\n        },\n      ],\n      messages: {\n        alwaysTrue:\n          'Unnecessary `{{name}}` call: the argument type guarantees it always returns `true`. Replace the call with `true`.',\n        alwaysFalse:\n          'Unnecessary `{{name}}` call: the argument type guarantees it always returns `false`. Replace the call with `false`.',\n        replaceTypeGuard:\n          'Unnecessary `{{from}}` call: the argument can only be narrowed by `{{to}}`. Use `{{to}}` instead.',\n      },\n    },\n\n    create: (context) => {\n      const options = context.options[0];\n\n      const parserServices = ESLintUtils.getParserServices(context);\n\n      const compilerOptions = parserServices.program.getCompilerOptions();\n\n      // Without `strictNullChecks`, `null` / `undefined` are erased from the type\n      // system, so reasoning about nullish narrowing is unsound. Disable entirely.\n      const strictNullChecks =\n        compilerOptions.strictNullChecks ?? compilerOptions.strict ?? false;\n\n      if (!strictNullChecks) return {};\n\n      const checker = parserServices.program.getTypeChecker();\n\n      const sourceCode = context.sourceCode;\n\n      const program = sourceCode.ast;\n\n      const ignored = new Set(options?.ignore);\n\n      const tsDataForgeImport = getTsDataForgeImport(program);\n\n      const resolveGuard = buildCalleeResolver(tsDataForgeImport);\n\n      const buildReplaceFix =\n        (\n          isNamespace: boolean,\n          // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types\n          propertyNode: TSESTree.Node,\n          replacement: string,\n        ): TSESLint.ReportFixFunction =>\n        (fixer) => {\n          // A namespace member access (`tf.isX`) exposes every export, so the\n          // canonical name is always in scope.\n          if (isNamespace) {\n            return [fixer.replaceText(propertyNode, replacement)];\n          }\n\n          // If the replacement guard is already imported (possibly under an\n          // alias), rename to its in-scope local name. Otherwise add a new\n          // import and rename to the canonical name.\n          const localName = getImportedLocalName(\n            tsDataForgeImport,\n            replacement,\n          );\n\n          if (localName !== undefined) {\n            return [fixer.replaceText(propertyNode, localName)];\n          }\n\n          return [\n            ...buildImportFixes(fixer, program, tsDataForgeImport, [\n              replacement,\n            ]),\n            fixer.replaceText(propertyNode, replacement),\n          ];\n        };\n\n      const reportConstant = (\n        node: DeepReadonly<TSESTree.CallExpression>,\n        name: string,\n        value: boolean,\n        argument: DeepReadonly<TSESTree.Expression>,\n      ): void => {\n        // Replacing the call with a literal drops the argument expression, so only\n        // autofix when evaluating it cannot have observable side effects.\n        const canFix = isSideEffectFreeArg(argument);\n\n        context.report({\n          // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n          node: node as TSESTree.Node,\n          messageId: value ? 'alwaysTrue' : 'alwaysFalse',\n          data: { name },\n          fix: canFix\n            ? (fixer) =>\n                fixer.replaceText(\n                  // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n                  node as TSESTree.Node,\n                  value ? 'true' : 'false',\n                )\n            : undefined,\n        });\n      };\n\n      const reportReplace = (\n        node: DeepReadonly<TSESTree.CallExpression>,\n        from: string,\n        to: string,\n        isNamespace: boolean,\n        // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types\n        propertyNode: TSESTree.Node,\n      ): void => {\n        context.report({\n          // eslint-disable-next-line total-functions/no-unsafe-type-assertion\n          node: node as TSESTree.Node,\n          messageId: 'replaceTypeGuard',\n          data: { from, to },\n          fix: buildReplaceFix(isNamespace, propertyNode, to),\n        });\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 { canonicalName, propertyNode, isNamespace } = resolved;\n\n          if (ignored.has(canonicalName)) return;\n\n          const spec = GUARD_SPECS[canonicalName];\n\n          if (spec === undefined) return;\n\n          const argTsNode = parserServices.esTreeNodeToTSNodeMap.get(argument);\n\n          const argType = checker.getTypeAtLocation(argTsNode);\n\n          const parts = collectUnionParts(argType);\n\n          if (parts === undefined) return; // opaque / generic → bail conservatively\n\n          const inputAtoms = new Set(parts.map(classifyAtom));\n\n          const hasMemberOutsideTarget = (\n            atoms: readonly AtomKey[],\n          ): boolean => {\n            const targetSet = new Set<Atom>(atoms);\n\n            return parts.some((p) => !targetSet.has(classifyAtom(p)));\n          };\n\n          switch (spec.kind) {\n            case 'excludeFrom': {\n              const removable = spec.atoms.filter((a) => inputAtoms.has(a));\n\n              if (removable.length === 0) {\n                // Nothing to exclude → the guard always holds.\n                reportConstant(node, canonicalName, true, argument);\n              } else if (!hasMemberOutsideTarget(spec.atoms)) {\n                // Every member is excluded → the guard never holds.\n                reportConstant(node, canonicalName, false, argument);\n              } else if (removable.length < spec.atoms.length) {\n                const replacement = spec.replacements?.[joinAtoms(removable)];\n\n                if (replacement !== undefined) {\n                  reportReplace(\n                    node,\n                    canonicalName,\n                    replacement,\n                    isNamespace,\n                    propertyNode,\n                  );\n                }\n              }\n\n              break;\n            }\n\n            case 'narrowTo': {\n              const present = spec.atoms.filter((a) => inputAtoms.has(a));\n\n              if (present.length === 0) {\n                // No member is in the target set → the guard never holds.\n                reportConstant(node, canonicalName, false, argument);\n              } else if (!hasMemberOutsideTarget(spec.atoms)) {\n                // Input ⊆ target → the guard always holds and narrows nothing.\n                reportConstant(node, canonicalName, true, argument);\n              } else if (present.length < spec.atoms.length) {\n                const replacement = spec.replacements?.[joinAtoms(present)];\n\n                if (replacement !== undefined) {\n                  reportReplace(\n                    node,\n                    canonicalName,\n                    replacement,\n                    isNamespace,\n                    propertyNode,\n                  );\n                }\n              }\n\n              break;\n            }\n\n            case 'record': {\n              if (parts.every((p) => isGuaranteedRecord(p, checker))) {\n                // Every member already satisfies `UnknownRecord`.\n                reportConstant(node, canonicalName, true, argument);\n              } else if (\n                parts.every((p) => isGuaranteedNotRecord(p, checker))\n              ) {\n                // No member can ever be a non-null, non-array object.\n                reportConstant(node, canonicalName, false, argument);\n              }\n\n              break;\n            }\n\n            case 'nonEmptyString': {\n              const hasNullish =\n                inputAtoms.has('undefined') || inputAtoms.has('null');\n\n              const nonNullishParts = parts.filter((p) => {\n                const atom = classifyAtom(p);\n\n                return atom !== 'undefined' && atom !== 'null';\n              });\n\n              if (!nonNullishParts.some(couldBeNonEmptyString)) {\n                // No member can be a non-empty string → the guard never holds.\n                reportConstant(node, canonicalName, false, argument);\n\n                break;\n              }\n\n              if (\n                nonNullishParts.some(\n                  (p) => !isGuaranteedNonEmptyString(p, checker),\n                )\n              ) {\n                break; // still does real string/empty work\n              }\n\n              if (hasNullish) {\n                reportReplace(\n                  node,\n                  canonicalName,\n                  'isNonNullish',\n                  isNamespace,\n                  propertyNode,\n                );\n              } else {\n                reportConstant(node, canonicalName, true, argument);\n              }\n\n              break;\n            }\n          }\n        },\n      };\n    },\n    defaultOptions: [{}],\n  } as const;\n\n/**\n * Decomposes a type into its union members. Returns `undefined` when any member\n * is opaque (`any` / `unknown` / `never`) or deferred (type parameter, indexed\n * access, …), signalling that the rule should not draw conclusions.\n */\n// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types\nconst collectUnionParts = (type: ts.Type): readonly ts.Type[] | undefined => {\n  const parts = type.isUnion() ? type.types : ([type] as const);\n\n  for (const part of parts) {\n    if ((part.flags & DEFERRED_OR_OPAQUE_FLAGS) !== 0) return undefined;\n  }\n\n  return parts;\n};\n\n/**\n * Whether `isRecord` is guaranteed to accept this (non-union) type.\n *\n * `isRecord` narrows to `UnknownRecord` (`ReadonlyRecord<string, unknown>`), so\n * a string index signature is exactly what it asks for and its value type is\n * `unknown`, which anything satisfies. Arrays and callables are excluded even\n * when they carry one, because `isRecord` rejects them at runtime\n * (`Array.isArray` is true; `typeof fn === 'object'` is false).\n *\n * Deliberately conservative: an object type without an index signature of its\n * own is reported as neither guaranteed-accepted nor guaranteed-rejected, even\n * where TypeScript would accept it through an implicit index signature.\n */\nconst isGuaranteedRecord = (\n  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types\n  type: ts.Type,\n  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types\n  checker: ts.TypeChecker,\n): boolean =>\n  checker.getIndexInfoOfType(type, ts.IndexKind.String) !== undefined &&\n  !isCallableType(type, checker) &&\n  !checker.isArrayType(type) &&\n  !checker.isTupleType(type);\n\n/**\n * Whether `isRecord` is guaranteed to reject this (non-union) type: every\n * primitive (`null` included), every array or tuple, and every callable fails\n * its `typeof x === 'object' && x !== null && !Array.isArray(x)` check.\n */\nconst isGuaranteedNotRecord = (\n  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types\n  type: ts.Type,\n  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types\n  checker: ts.TypeChecker,\n): boolean =>\n  classifyAtom(type) !== 'other' ||\n  checker.isArrayType(type) ||\n  checker.isTupleType(type) ||\n  isCallableType(type, checker);\n\nconst isCallableType = (\n  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types\n  type: ts.Type,\n  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types\n  checker: ts.TypeChecker,\n): boolean =>\n  checker.getSignaturesOfType(type, ts.SignatureKind.Call).length > 0 ||\n  checker.getSignaturesOfType(type, ts.SignatureKind.Construct).length > 0;\n\n/** Classifies a single (non-union) type into a primitive {@link Atom}. */\n// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types\nconst classifyAtom = (type: ts.Type): Atom => {\n  const { flags } = type;\n\n  if ((flags & ts.TypeFlags.Undefined) !== 0) return 'undefined';\n\n  if ((flags & ts.TypeFlags.Null) !== 0) return 'null';\n\n  if ((flags & ts.TypeFlags.BooleanLike) !== 0) return 'boolean';\n\n  if ((flags & ts.TypeFlags.NumberLike) !== 0) return 'number';\n\n  if ((flags & ts.TypeFlags.StringLike) !== 0) return 'string';\n\n  if ((flags & ts.TypeFlags.BigIntLike) !== 0) return 'bigint';\n\n  if ((flags & ts.TypeFlags.ESSymbolLike) !== 0) return 'symbol';\n\n  // Branded primitives (e.g. `NonEmptyString = string & {...}`) are\n  // intersections; classify them by their underlying primitive constituent.\n  if (type.isIntersection()) {\n    for (const constituent of type.types) {\n      const atom = classifyAtom(constituent);\n\n      if (atom !== 'other') return atom;\n    }\n  }\n\n  return 'other';\n};\n\nconst ATOM_ORDER: readonly AtomKey[] = [\n  'undefined',\n  'null',\n  'boolean',\n  'number',\n  'string',\n  'bigint',\n  'symbol',\n] as const;\n\n/** A stable key for a set of atoms, used to look up replacement guards. */\nconst joinAtoms = (atoms: readonly AtomKey[]): string =>\n  ATOM_ORDER.filter((atom) => atoms.includes(atom)).join('|');\n\n/**\n * Returns `true` when the type is guaranteed to be a non-empty string: either a\n * non-empty string literal or a value branded as `NonEmptyString`\n * (`MinLengthString<N>` with `N >= 1`).\n */\nconst isGuaranteedNonEmptyString = (\n  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types\n  type: ts.Type,\n  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types\n  checker: ts.TypeChecker,\n): boolean => {\n  if (type.isStringLiteral()) return type.value !== '';\n\n  if (type.getProperty(BRAND_MARKER_PROPERTY) === undefined) return false;\n\n  const minLengthSymbol = type.getProperty(MIN_LENGTH_BRAND_KEY);\n\n  if (minLengthSymbol === undefined) return false;\n\n  // The `MinLength` brand value is `MinLengthTuple<N, 0>`; it has a required\n  // first element (`'0'`) exactly when `N >= 1`, i.e. the string is non-empty.\n  // `MinLengthString<0>` brands with a plain array and has no such element.\n  return (\n    checker.getTypeOfSymbol(minLengthSymbol).getProperty('0') !== undefined\n  );\n};\n\n/**\n * Returns `true` when the type can possibly be a non-empty string (a general\n * `string`, a branded string, or a non-empty string literal). The empty string\n * literal and non-string types cannot.\n */\n// eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types\nconst couldBeNonEmptyString = (type: ts.Type): boolean => {\n  if (type.isStringLiteral()) return type.value !== '';\n\n  return classifyAtom(type) === 'string';\n};\n\n/**\n * Returns `true` when evaluating the expression cannot have observable side\n * effects, so replacing the surrounding call with a literal is safe. Limited to\n * simple references (identifiers, `this`, literals, and member-access chains).\n */\n\nconst isSideEffectFreeArg = (node: DeepReadonly<TSESTree.Node>): boolean => {\n  // `node.type` is one of 130+ AST kinds; only a handful are relevant here.\n  // eslint-disable-next-line @typescript-eslint/switch-exhaustiveness-check\n  switch (node.type) {\n    case AST_NODE_TYPES.Identifier:\n    case AST_NODE_TYPES.ThisExpression:\n    case AST_NODE_TYPES.Literal:\n      return true;\n\n    case AST_NODE_TYPES.MemberExpression:\n      return (\n        isSideEffectFreeArg(node.object) &&\n        (!node.computed || isSideEffectFreeArg(node.property))\n      );\n\n    default:\n      return false;\n  }\n};\n"],"names":[],"mappings":";;;;AAsDA,MAAM,qBAAA,GACJ,4DAAA;AAQF,MAAM,oBAAA,GAAuB,WAAA;AAE7B,MAAM,4BAAA,GAAiE;AAAA,EACrE,SAAA,EAAW,gBAAA;AAAA,EACX,IAAA,EAAM;AACR,CAAA;AAEA,MAAM,2BAAA,GAAgE;AAAA,EACpE,SAAA,EAAW,aAAA;AAAA,EACX,IAAA,EAAM;AACR,CAAA;AAEA,MAAM,WAAA,GAAuD;AAAA,EAC3D,aAAa,EAAE,IAAA,EAAM,YAAY,KAAA,EAAO,CAAC,WAAW,CAAA,EAAE;AAAA,EACtD,gBAAgB,EAAE,IAAA,EAAM,eAAe,KAAA,EAAO,CAAC,WAAW,CAAA,EAAE;AAAA,EAC5D,QAAQ,EAAE,IAAA,EAAM,YAAY,KAAA,EAAO,CAAC,MAAM,CAAA,EAAE;AAAA,EAC5C,WAAW,EAAE,IAAA,EAAM,eAAe,KAAA,EAAO,CAAC,MAAM,CAAA,EAAE;AAAA,EAClD,WAAW,EAAE,IAAA,EAAM,YAAY,KAAA,EAAO,CAAC,SAAS,CAAA,EAAE;AAAA,EAClD,cAAc,EAAE,IAAA,EAAM,eAAe,KAAA,EAAO,CAAC,SAAS,CAAA,EAAE;AAAA,EACxD,UAAU,EAAE,IAAA,EAAM,YAAY,KAAA,EAAO,CAAC,QAAQ,CAAA,EAAE;AAAA,EAChD,aAAa,EAAE,IAAA,EAAM,eAAe,KAAA,EAAO,CAAC,QAAQ,CAAA,EAAE;AAAA,EACtD,UAAU,EAAE,IAAA,EAAM,YAAY,KAAA,EAAO,CAAC,QAAQ,CAAA,EAAE;AAAA,EAChD,aAAa,EAAE,IAAA,EAAM,eAAe,KAAA,EAAO,CAAC,QAAQ,CAAA,EAAE;AAAA,EACtD,UAAU,EAAE,IAAA,EAAM,YAAY,KAAA,EAAO,CAAC,QAAQ,CAAA,EAAE;AAAA,EAChD,aAAa,EAAE,IAAA,EAAM,eAAe,KAAA,EAAO,CAAC,QAAQ,CAAA,EAAE;AAAA,EACtD,UAAU,EAAE,IAAA,EAAM,YAAY,KAAA,EAAO,CAAC,QAAQ,CAAA,EAAE;AAAA,EAChD,aAAa,EAAE,IAAA,EAAM,eAAe,KAAA,EAAO,CAAC,QAAQ,CAAA,EAAE;AAAA,EACtD,SAAA,EAAW;AAAA,IACT,IAAA,EAAM,UAAA;AAAA,IACN,KAAA,EAAO,CAAC,MAAA,EAAQ,WAAW,CAAA;AAAA,IAC3B,YAAA,EAAc;AAAA,GAChB;AAAA,EACA,YAAA,EAAc;AAAA,IACZ,IAAA,EAAM,aAAA;AAAA,IACN,KAAA,EAAO,CAAC,MAAA,EAAQ,WAAW,CAAA;AAAA,IAC3B,YAAA,EAAc;AAAA,GAChB;AAAA,EACA,gBAAA,EAAkB,EAAE,IAAA,EAAM,gBAAA,EAAiB;AAAA,EAC3C,QAAA,EAAU,EAAE,IAAA,EAAM,QAAA;AACpB,CAAA;AAEA,MAAM,wBAAA,GACJ,GAAG,SAAA,CAAU,GAAA,GACb,GAAG,SAAA,CAAU,OAAA,GACb,GAAG,SAAA,CAAU,KAAA,GACb,GAAG,SAAA,CAAU,aAAA,GACb,GAAG,SAAA,CAAU,aAAA,GACb,GAAG,SAAA,CAAU,WAAA,GACb,GAAG,SAAA,CAAU,YAAA;AAER,MAAM,sBAAA,GACX;AAAA,EACE,IAAA,EAAM;AAAA,IACJ,IAAA,EAAM,YAAA;AAAA,IACN,IAAA,EAAM;AAAA,MACJ,WAAA,EACE;AAAA,KACJ;AAAA,IACA,OAAA,EAAS,MAAA;AAAA,IACT,MAAA,EAAQ;AAAA,MACN;AAAA,QACE,IAAA,EAAM,QAAA;AAAA,QACN,UAAA,EAAY;AAAA,UACV,MAAA,EAAQ;AAAA,YACN,IAAA,EAAM,OAAA;AAAA,YACN,KAAA,EAAO,EAAE,IAAA,EAAM,QAAA,EAAS;AAAA,YACxB,WAAA,EACE;AAAA;AACJ,SACF;AAAA,QACA,oBAAA,EAAsB;AAAA;AACxB,KACF;AAAA,IACA,QAAA,EAAU;AAAA,MACR,UAAA,EACE,mHAAA;AAAA,MACF,WAAA,EACE,qHAAA;AAAA,MACF,gBAAA,EACE;AAAA;AACJ,GACF;AAAA,EAEA,MAAA,EAAQ,CAAC,OAAA,KAAY;AACnB,IAAA,MAAM,OAAA,GAAU,OAAA,CAAQ,OAAA,CAAQ,CAAC,CAAA;AAEjC,IAAA,MAAM,cAAA,GAAiB,WAAA,CAAY,iBAAA,CAAkB,OAAO,CAAA;AAE5D,IAAA,MAAM,eAAA,GAAkB,cAAA,CAAe,OAAA,CAAQ,kBAAA,EAAmB;AAIlE,IAAA,MAAM,gBAAA,GACJ,eAAA,CAAgB,gBAAA,IAAoB,eAAA,CAAgB,MAAA,IAAU,KAAA;AAEhE,IAAA,IAAI,CAAC,gBAAA,EAAkB,OAAO,EAAC;AAE/B,IAAA,MAAM,OAAA,GAAU,cAAA,CAAe,OAAA,CAAQ,cAAA,EAAe;AAEtD,IAAA,MAAM,aAAa,OAAA,CAAQ,UAAA;AAE3B,IAAA,MAAM,UAAU,UAAA,CAAW,GAAA;AAE3B,IAAA,MAAM,OAAA,GAAU,IAAI,GAAA,CAAI,OAAA,EAAS,MAAM,CAAA;AAEvC,IAAA,MAAM,iBAAA,GAAoB,qBAAqB,OAAO,CAAA;AAEtD,IAAA,MAAM,YAAA,GAAe,oBAAoB,iBAAiB,CAAA;AAE1D,IAAA,MAAM,kBACJ,CACE,WAAA,EAEA,YAAA,EACA,WAAA,KAEF,CAAC,KAAA,KAAU;AAGT,MAAA,IAAI,WAAA,EAAa;AACf,QAAA,OAAO,CAAC,KAAA,CAAM,WAAA,CAAY,YAAA,EAAc,WAAW,CAAC,CAAA;AAAA,MACtD;AAKA,MAAA,MAAM,SAAA,GAAY,oBAAA;AAAA,QAChB,iBAAA;AAAA,QACA;AAAA,OACF;AAEA,MAAA,IAAI,cAAc,MAAA,EAAW;AAC3B,QAAA,OAAO,CAAC,KAAA,CAAM,WAAA,CAAY,YAAA,EAAc,SAAS,CAAC,CAAA;AAAA,MACpD;AAEA,MAAA,OAAO;AAAA,QACL,GAAG,gBAAA,CAAiB,KAAA,EAAO,OAAA,EAAS,iBAAA,EAAmB;AAAA,UACrD;AAAA,SACD,CAAA;AAAA,QACD,KAAA,CAAM,WAAA,CAAY,YAAA,EAAc,WAAW;AAAA,OAC7C;AAAA,IACF,CAAA;AAEF,IAAA,MAAM,cAAA,GAAiB,CACrB,IAAA,EACA,IAAA,EACA,OACA,QAAA,KACS;AAGT,MAAA,MAAM,MAAA,GAAS,oBAAoB,QAAQ,CAAA;AAE3C,MAAA,OAAA,CAAQ,MAAA,CAAO;AAAA;AAAA,QAEb,IAAA;AAAA,QACA,SAAA,EAAW,QAAQ,YAAA,GAAe,aAAA;AAAA,QAClC,IAAA,EAAM,EAAE,IAAA,EAAK;AAAA,QACb,GAAA,EAAK,MAAA,GACD,CAAC,KAAA,KACC,KAAA,CAAM,WAAA;AAAA;AAAA,UAEJ,IAAA;AAAA,UACA,QAAQ,MAAA,GAAS;AAAA,SACnB,GACF;AAAA,OACL,CAAA;AAAA,IACH,CAAA;AAEA,IAAA,MAAM,gBAAgB,CACpB,IAAA,EACA,IAAA,EACA,EAAA,EACA,aAEA,YAAA,KACS;AACT,MAAA,OAAA,CAAQ,MAAA,CAAO;AAAA;AAAA,QAEb,IAAA;AAAA,QACA,SAAA,EAAW,kBAAA;AAAA,QACX,IAAA,EAAM,EAAE,IAAA,EAAM,EAAA,EAAG;AAAA,QACjB,GAAA,EAAK,eAAA,CAAgB,WAAA,EAAa,YAAA,EAAc,EAAE;AAAA,OACnD,CAAA;AAAA,IACH,CAAA;AAEA,IAAA,OAAO;AAAA,MACL,cAAA,EAAgB,CAAC,IAAA,KAAS;AACxB,QAAA,IAAI,IAAA,CAAK,SAAA,CAAU,MAAA,KAAW,CAAA,EAAG;AAEjC,QAAA,MAAM,QAAA,GAAW,IAAA,CAAK,SAAA,CAAU,CAAC,CAAA;AAEjC,QAAA,IACE,QAAA,KAAa,MAAA,IACb,QAAA,CAAS,IAAA,KAAS,eAAe,aAAA,EACjC;AACA,UAAA;AAAA,QACF;AAEA,QAAA,MAAM,QAAA,GAAW,YAAA,CAAa,IAAA,CAAK,MAAM,CAAA;AAEzC,QAAA,IAAI,aAAa,MAAA,EAAW;AAE5B,QAAA,MAAM,EAAE,aAAA,EAAe,YAAA,EAAc,WAAA,EAAY,GAAI,QAAA;AAErD,QAAA,IAAI,OAAA,CAAQ,GAAA,CAAI,aAAa,CAAA,EAAG;AAEhC,QAAA,MAAM,IAAA,GAAO,YAAY,aAAa,CAAA;AAEtC,QAAA,IAAI,SAAS,MAAA,EAAW;AAExB,QAAA,MAAM,SAAA,GAAY,cAAA,CAAe,qBAAA,CAAsB,GAAA,CAAI,QAAQ,CAAA;AAEnE,QAAA,MAAM,OAAA,GAAU,OAAA,CAAQ,iBAAA,CAAkB,SAAS,CAAA;AAEnD,QAAA,MAAM,KAAA,GAAQ,kBAAkB,OAAO,CAAA;AAEvC,QAAA,IAAI,UAAU,MAAA,EAAW;AAEzB,QAAA,MAAM,aAAa,IAAI,GAAA,CAAI,KAAA,CAAM,GAAA,CAAI,YAAY,CAAC,CAAA;AAElD,QAAA,MAAM,sBAAA,GAAyB,CAC7B,KAAA,KACY;AACZ,UAAA,MAAM,SAAA,GAAY,IAAI,GAAA,CAAU,KAAK,CAAA;AAErC,UAAA,OAAO,KAAA,CAAM,IAAA,CAAK,CAAC,CAAA,KAAM,CAAC,UAAU,GAAA,CAAI,YAAA,CAAa,CAAC,CAAC,CAAC,CAAA;AAAA,QAC1D,CAAA;AAEA,QAAA,QAAQ,KAAK,IAAA;AAAM,UACjB,KAAK,aAAA,EAAe;AAClB,YAAA,MAAM,SAAA,GAAY,KAAK,KAAA,CAAM,MAAA,CAAO,CAAC,CAAA,KAAM,UAAA,CAAW,GAAA,CAAI,CAAC,CAAC,CAAA;AAE5D,YAAA,IAAI,SAAA,CAAU,WAAW,CAAA,EAAG;AAE1B,cAAA,cAAA,CAAe,IAAA,EAAM,aAAA,EAAe,IAAA,EAAM,QAAQ,CAAA;AAAA,YACpD,CAAA,MAAA,IAAW,CAAC,sBAAA,CAAuB,IAAA,CAAK,KAAK,CAAA,EAAG;AAE9C,cAAA,cAAA,CAAe,IAAA,EAAM,aAAA,EAAe,KAAA,EAAO,QAAQ,CAAA;AAAA,YACrD,CAAA,MAAA,IAAW,SAAA,CAAU,MAAA,GAAS,IAAA,CAAK,MAAM,MAAA,EAAQ;AAC/C,cAAA,MAAM,WAAA,GAAc,IAAA,CAAK,YAAA,GAAe,SAAA,CAAU,SAAS,CAAC,CAAA;AAE5D,cAAA,IAAI,gBAAgB,MAAA,EAAW;AAC7B,gBAAA,aAAA;AAAA,kBACE,IAAA;AAAA,kBACA,aAAA;AAAA,kBACA,WAAA;AAAA,kBACA,WAAA;AAAA,kBACA;AAAA,iBACF;AAAA,cACF;AAAA,YACF;AAEA,YAAA;AAAA,UACF;AAAA,UAEA,KAAK,UAAA,EAAY;AACf,YAAA,MAAM,OAAA,GAAU,KAAK,KAAA,CAAM,MAAA,CAAO,CAAC,CAAA,KAAM,UAAA,CAAW,GAAA,CAAI,CAAC,CAAC,CAAA;AAE1D,YAAA,IAAI,OAAA,CAAQ,WAAW,CAAA,EAAG;AAExB,cAAA,cAAA,CAAe,IAAA,EAAM,aAAA,EAAe,KAAA,EAAO,QAAQ,CAAA;AAAA,YACrD,CAAA,MAAA,IAAW,CAAC,sBAAA,CAAuB,IAAA,CAAK,KAAK,CAAA,EAAG;AAE9C,cAAA,cAAA,CAAe,IAAA,EAAM,aAAA,EAAe,IAAA,EAAM,QAAQ,CAAA;AAAA,YACpD,CAAA,MAAA,IAAW,OAAA,CAAQ,MAAA,GAAS,IAAA,CAAK,MAAM,MAAA,EAAQ;AAC7C,cAAA,MAAM,WAAA,GAAc,IAAA,CAAK,YAAA,GAAe,SAAA,CAAU,OAAO,CAAC,CAAA;AAE1D,cAAA,IAAI,gBAAgB,MAAA,EAAW;AAC7B,gBAAA,aAAA;AAAA,kBACE,IAAA;AAAA,kBACA,aAAA;AAAA,kBACA,WAAA;AAAA,kBACA,WAAA;AAAA,kBACA;AAAA,iBACF;AAAA,cACF;AAAA,YACF;AAEA,YAAA;AAAA,UACF;AAAA,UAEA,KAAK,QAAA,EAAU;AACb,YAAA,IAAI,KAAA,CAAM,MAAM,CAAC,CAAA,KAAM,mBAAmB,CAAA,EAAG,OAAO,CAAC,CAAA,EAAG;AAEtD,cAAA,cAAA,CAAe,IAAA,EAAM,aAAA,EAAe,IAAA,EAAM,QAAQ,CAAA;AAAA,YACpD,CAAA,MAAA,IACE,MAAM,KAAA,CAAM,CAAC,MAAM,qBAAA,CAAsB,CAAA,EAAG,OAAO,CAAC,CAAA,EACpD;AAEA,cAAA,cAAA,CAAe,IAAA,EAAM,aAAA,EAAe,KAAA,EAAO,QAAQ,CAAA;AAAA,YACrD;AAEA,YAAA;AAAA,UACF;AAAA,UAEA,KAAK,gBAAA,EAAkB;AACrB,YAAA,MAAM,aACJ,UAAA,CAAW,GAAA,CAAI,WAAW,CAAA,IAAK,UAAA,CAAW,IAAI,MAAM,CAAA;AAEtD,YAAA,MAAM,eAAA,GAAkB,KAAA,CAAM,MAAA,CAAO,CAAC,CAAA,KAAM;AAC1C,cAAA,MAAM,IAAA,GAAO,aAAa,CAAC,CAAA;AAE3B,cAAA,OAAO,IAAA,KAAS,eAAe,IAAA,KAAS,MAAA;AAAA,YAC1C,CAAC,CAAA;AAED,YAAA,IAAI,CAAC,eAAA,CAAgB,IAAA,CAAK,qBAAqB,CAAA,EAAG;AAEhD,cAAA,cAAA,CAAe,IAAA,EAAM,aAAA,EAAe,KAAA,EAAO,QAAQ,CAAA;AAEnD,cAAA;AAAA,YACF;AAEA,YAAA,IACE,eAAA,CAAgB,IAAA;AAAA,cACd,CAAC,CAAA,KAAM,CAAC,0BAAA,CAA2B,GAAG,OAAO;AAAA,aAC/C,EACA;AACA,cAAA;AAAA,YACF;AAEA,YAAA,IAAI,UAAA,EAAY;AACd,cAAA,aAAA;AAAA,gBACE,IAAA;AAAA,gBACA,aAAA;AAAA,gBACA,cAAA;AAAA,gBACA,WAAA;AAAA,gBACA;AAAA,eACF;AAAA,YACF,CAAA,MAAO;AACL,cAAA,cAAA,CAAe,IAAA,EAAM,aAAA,EAAe,IAAA,EAAM,QAAQ,CAAA;AAAA,YACpD;AAEA,YAAA;AAAA,UACF;AAAA;AACF,MACF;AAAA,KACF;AAAA,EACF,CAAA;AAAA,EACA,cAAA,EAAgB,CAAC,EAAE;AACrB;AAQF,MAAM,iBAAA,GAAoB,CAAC,IAAA,KAAkD;AAC3E,EAAA,MAAM,QAAQ,IAAA,CAAK,OAAA,KAAY,IAAA,CAAK,KAAA,GAAS,CAAC,IAAI,CAAA;AAElD,EAAA,KAAA,MAAW,QAAQ,KAAA,EAAO;AACxB,IAAA,IAAA,CAAK,IAAA,CAAK,KAAA,GAAQ,wBAAA,MAA8B,CAAA,EAAG,OAAO,MAAA;AAAA,EAC5D;AAEA,EAAA,OAAO,KAAA;AACT,CAAA;AAeA,MAAM,kBAAA,GAAqB,CAEzB,IAAA,EAEA,OAAA,KAEA,OAAA,CAAQ,mBAAmB,IAAA,EAAM,EAAA,CAAG,SAAA,CAAU,MAAM,CAAA,KAAM,MAAA,IAC1D,CAAC,cAAA,CAAe,IAAA,EAAM,OAAO,CAAA,IAC7B,CAAC,OAAA,CAAQ,WAAA,CAAY,IAAI,CAAA,IACzB,CAAC,OAAA,CAAQ,WAAA,CAAY,IAAI,CAAA;AAO3B,MAAM,wBAAwB,CAE5B,IAAA,EAEA,YAEA,YAAA,CAAa,IAAI,MAAM,OAAA,IACvB,OAAA,CAAQ,WAAA,CAAY,IAAI,KACxB,OAAA,CAAQ,WAAA,CAAY,IAAI,CAAA,IACxB,cAAA,CAAe,MAAM,OAAO,CAAA;AAE9B,MAAM,cAAA,GAAiB,CAErB,IAAA,EAEA,OAAA,KAEA,QAAQ,mBAAA,CAAoB,IAAA,EAAM,GAAG,aAAA,CAAc,IAAI,EAAE,MAAA,GAAS,CAAA,IAClE,QAAQ,mBAAA,CAAoB,IAAA,EAAM,GAAG,aAAA,CAAc,SAAS,EAAE,MAAA,GAAS,CAAA;AAIzE,MAAM,YAAA,GAAe,CAAC,IAAA,KAAwB;AAC5C,EAAA,MAAM,EAAE,OAAM,GAAI,IAAA;AAElB,EAAA,IAAA,CAAK,KAAA,GAAQ,EAAA,CAAG,SAAA,CAAU,SAAA,MAAe,GAAG,OAAO,WAAA;AAEnD,EAAA,IAAA,CAAK,KAAA,GAAQ,EAAA,CAAG,SAAA,CAAU,IAAA,MAAU,GAAG,OAAO,MAAA;AAE9C,EAAA,IAAA,CAAK,KAAA,GAAQ,EAAA,CAAG,SAAA,CAAU,WAAA,MAAiB,GAAG,OAAO,SAAA;AAErD,EAAA,IAAA,CAAK,KAAA,GAAQ,EAAA,CAAG,SAAA,CAAU,UAAA,MAAgB,GAAG,OAAO,QAAA;AAEpD,EAAA,IAAA,CAAK,KAAA,GAAQ,EAAA,CAAG,SAAA,CAAU,UAAA,MAAgB,GAAG,OAAO,QAAA;AAEpD,EAAA,IAAA,CAAK,KAAA,GAAQ,EAAA,CAAG,SAAA,CAAU,UAAA,MAAgB,GAAG,OAAO,QAAA;AAEpD,EAAA,IAAA,CAAK,KAAA,GAAQ,EAAA,CAAG,SAAA,CAAU,YAAA,MAAkB,GAAG,OAAO,QAAA;AAItD,EAAA,IAAI,IAAA,CAAK,gBAAe,EAAG;AACzB,IAAA,KAAA,MAAW,WAAA,IAAe,KAAK,KAAA,EAAO;AACpC,MAAA,MAAM,IAAA,GAAO,aAAa,WAAW,CAAA;AAErC,MAAA,IAAI,IAAA,KAAS,SAAS,OAAO,IAAA;AAAA,IAC/B;AAAA,EACF;AAEA,EAAA,OAAO,OAAA;AACT,CAAA;AAEA,MAAM,UAAA,GAAiC;AAAA,EACrC,WAAA;AAAA,EACA,MAAA;AAAA,EACA,SAAA;AAAA,EACA,QAAA;AAAA,EACA,QAAA;AAAA,EACA,QAAA;AAAA,EACA;AACF,CAAA;AAGA,MAAM,SAAA,GAAY,CAAC,KAAA,KACjB,UAAA,CAAW,MAAA,CAAO,CAAC,IAAA,KAAS,KAAA,CAAM,QAAA,CAAS,IAAI,CAAC,CAAA,CAAE,KAAK,GAAG,CAAA;AAO5D,MAAM,0BAAA,GAA6B,CAEjC,IAAA,EAEA,OAAA,KACY;AACZ,EAAA,IAAI,IAAA,CAAK,eAAA,EAAgB,EAAG,OAAO,KAAK,KAAA,KAAU,EAAA;AAElD,EAAA,IAAI,IAAA,CAAK,WAAA,CAAY,qBAAqB,CAAA,KAAM,QAAW,OAAO,KAAA;AAElE,EAAA,MAAM,eAAA,GAAkB,IAAA,CAAK,WAAA,CAAY,oBAAoB,CAAA;AAE7D,EAAA,IAAI,eAAA,KAAoB,QAAW,OAAO,KAAA;AAK1C,EAAA,OACE,QAAQ,eAAA,CAAgB,eAAe,CAAA,CAAE,WAAA,CAAY,GAAG,CAAA,KAAM,MAAA;AAElE,CAAA;AAQA,MAAM,qBAAA,GAAwB,CAAC,IAAA,KAA2B;AACxD,EAAA,IAAI,IAAA,CAAK,eAAA,EAAgB,EAAG,OAAO,KAAK,KAAA,KAAU,EAAA;AAElD,EAAA,OAAO,YAAA,CAAa,IAAI,CAAA,KAAM,QAAA;AAChC,CAAA;AAQA,MAAM,mBAAA,GAAsB,CAAC,IAAA,KAA+C;AAG1E,EAAA,QAAQ,KAAK,IAAA;AAAM,IACjB,KAAK,cAAA,CAAe,UAAA;AAAA,IACpB,KAAK,cAAA,CAAe,cAAA;AAAA,IACpB,KAAK,cAAA,CAAe,OAAA;AAClB,MAAA,OAAO,IAAA;AAAA,IAET,KAAK,cAAA,CAAe,gBAAA;AAClB,MAAA,OACE,mBAAA,CAAoB,KAAK,MAAM,CAAA,KAC9B,CAAC,IAAA,CAAK,QAAA,IAAY,mBAAA,CAAoB,IAAA,CAAK,QAAQ,CAAA,CAAA;AAAA,IAGxD;AACE,MAAA,OAAO,KAAA;AAAA;AAEb,CAAA;;;;"}

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

@@ -1,6 +1,6 @@
 import { type TSESLint } from '@typescript-eslint/utils';
 type Options = readonly [];
-type MessageIds = 'useIsRecordAndHasKey';
+type MessageIds = 'useIsRecordAndHasKey' | 'useHasKey';
 export declare const preferIsRecordAndHasKey: TSESLint.RuleModule<MessageIds, Options>;
 export {};
 //# sourceMappingURL=prefer-is-record-and-has-key.d.mts.map

package/dist/rules/prefer-is-record-and-has-key.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"prefer-is-record-and-has-key.d.mts","sourceRoot":"","sources":["../../src/rules/prefer-is-record-and-has-key.mts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,QAAQ,EAEd,MAAM,0BAA0B,CAAC;AAOlC,KAAK,OAAO,GAAG,SAAS,EAAE,CAAC;AAE3B,KAAK,UAAU,GAAG,sBAAsB,CAAC;AAEzC,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,UAAU,CAAC,UAAU,EAAE,OAAO,CA4IjE,CAAC"}
+{"version":3,"file":"prefer-is-record-and-has-key.d.mts","sourceRoot":"","sources":["../../src/rules/prefer-is-record-and-has-key.mts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,QAAQ,EAEd,MAAM,0BAA0B,CAAC;AASlC,KAAK,OAAO,GAAG,SAAS,EAAE,CAAC;AAE3B,KAAK,UAAU,GAAG,sBAAsB,GAAG,WAAW,CAAC;AAEvD,eAAO,MAAM,uBAAuB,EAAE,QAAQ,CAAC,UAAU,CAAC,UAAU,EAAE,OAAO,CA4KjE,CAAC"}

package/dist/rules/prefer-is-record-and-has-key.mjs

@@ -1,4 +1,6 @@
 import { AST_NODE_TYPES } from '@typescript-eslint/utils';
+import { Arr } from 'ts-data-forge';
+import * as ts from 'typescript';
 import { getTsDataForgeImport, getNamedImports, buildImportFixes } from './import-utils.mjs';
 
 const preferIsRecordAndHasKey = {
@@ -10,13 +12,21 @@ const preferIsRecordAndHasKey = {
     fixable: "code",
     schema: [],
     messages: {
-      useIsRecordAndHasKey: "Replace `{{original}}` with `isRecord({{objName}}) && hasKey({{objName}}, {{keyName}})` from ts-data-forge."
+      useIsRecordAndHasKey: "Replace `{{original}}` with `isRecord({{objName}}) && hasKey({{objName}}, {{keyName}})` from ts-data-forge.",
+      useHasKey: "Replace `{{original}}` with `hasKey({{objName}}, {{keyName}})` from ts-data-forge."
     }
   },
   create: (context) => {
     const sourceCode = context.sourceCode;
     const program = sourceCode.ast;
     const tsDataForgeImport = getTsDataForgeImport(program);
+    const services = sourceCode.parserServices;
+    const checker = services?.program?.getTypeChecker();
+    const isKnownRecord = (expression) => {
+      if (checker === void 0) return false;
+      const tsNode = services?.esTreeNodeToTSNodeMap?.get(expression);
+      return tsNode !== void 0 && isAlreadyRecordType(checker, checker.getTypeAtLocation(tsNode));
+    };
     const mut_nodesToFix = [];
     return {
       // Handle Object.hasOwn(obj, key)
@@ -51,37 +61,38 @@ const preferIsRecordAndHasKey = {
       },
       "Program:exit": () => {
         const namedImports = getNamedImports(tsDataForgeImport);
-        const hasIsRecordImport = namedImports.includes("isRecord");
-        const hasHasKeyImport = namedImports.includes("hasKey");
+        const rewrites = mut_nodesToFix.map((entry) => ({
+          ...entry,
+          // A record-typed object makes the `isRecord(...)` conjunct always
+          // true, so it is left out of the replacement entirely.
+          needsIsRecord: !isKnownRecord(entry.objExpression)
+        }));
+        const importsToAdd = [
+          ...rewrites.some(({ needsIsRecord }) => needsIsRecord) && !namedImports.includes("isRecord") ? ["isRecord"] : [],
+          ...namedImports.includes("hasKey") ? [] : ["hasKey"]
+        ];
         for (const [
           index,
-          { node, objExpression, keyExpression }
-        ] of mut_nodesToFix.entries()) {
+          { node, objExpression, keyExpression, needsIsRecord }
+        ] of rewrites.entries()) {
           const objText = sourceCode.getText(objExpression);
           const keyText = sourceCode.getText(keyExpression);
           const originalText = sourceCode.getText(node);
           context.report({
             node,
-            messageId: "useIsRecordAndHasKey",
+            messageId: needsIsRecord ? "useIsRecordAndHasKey" : "useHasKey",
             data: {
               original: originalText,
               objName: objText,
               keyName: keyText
             },
             fix: (fixer) => {
-              const replacement = `(isRecord(${objText}) && hasKey(${objText}, ${keyText}))`;
-              const mut_importsToAdd = [];
-              if (!hasIsRecordImport) {
-                mut_importsToAdd.push("isRecord");
-              }
-              if (!hasHasKeyImport) {
-                mut_importsToAdd.push("hasKey");
-              }
-              const importFixes = index === 0 && mut_importsToAdd.length > 0 ? buildImportFixes(
+              const replacement = needsIsRecord ? `(isRecord(${objText}) && hasKey(${objText}, ${keyText}))` : `hasKey(${objText}, ${keyText})`;
+              const importFixes = index === 0 && importsToAdd.length > 0 ? buildImportFixes(
                 fixer,
                 program,
                 tsDataForgeImport,
-                mut_importsToAdd
+                importsToAdd
               ) : [];
               return [...importFixes, fixer.replaceText(node, replacement)];
             }
@@ -92,6 +103,9 @@ const preferIsRecordAndHasKey = {
   },
   defaultOptions: []
 };
+const isAlreadyRecordType = (checker, type) => type.isUnion() ? type.types.every((member) => isAlreadyRecordType(checker, member)) : checker.getIndexInfoOfType(type, ts.IndexKind.String) !== void 0 && Arr.isEmpty(checker.getSignaturesOfType(type, ts.SignatureKind.Call)) && Arr.isEmpty(
+  checker.getSignaturesOfType(type, ts.SignatureKind.Construct)
+) && !checker.isArrayType(type) && !checker.isTupleType(type);
 
 export { preferIsRecordAndHasKey };
 //# sourceMappingURL=prefer-is-record-and-has-key.mjs.map

package/dist/rules/prefer-is-record-and-has-key.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"prefer-is-record-and-has-key.mjs","sources":["../../src/rules/prefer-is-record-and-has-key.mts"],"sourcesContent":["import {\n  AST_NODE_TYPES,\n  type TSESLint,\n  type TSESTree,\n} from '@typescript-eslint/utils';\nimport {\n  buildImportFixes,\n  getNamedImports,\n  getTsDataForgeImport,\n} from './import-utils.mjs';\n\ntype Options = readonly [];\n\ntype MessageIds = 'useIsRecordAndHasKey';\n\nexport const preferIsRecordAndHasKey: TSESLint.RuleModule<MessageIds, Options> =\n  {\n    meta: {\n      type: 'suggestion',\n      docs: {\n        description:\n          'Replace `Object.hasOwn(obj, key)` or `key in obj` with `isRecord(obj) && hasKey(obj, key)` from ts-data-forge',\n      },\n      fixable: 'code',\n      schema: [],\n      messages: {\n        useIsRecordAndHasKey:\n          'Replace `{{original}}` with `isRecord({{objName}}) && hasKey({{objName}}, {{keyName}})` from ts-data-forge.',\n      },\n    },\n\n    create: (context) => {\n      const sourceCode = context.sourceCode;\n\n      const program = sourceCode.ast;\n\n      const tsDataForgeImport = getTsDataForgeImport(program);\n\n      const mut_nodesToFix: {\n        node: TSESTree.CallExpression | TSESTree.BinaryExpression;\n        objExpression: TSESTree.Expression;\n        keyExpression: TSESTree.Expression;\n      }[] = [];\n\n      return {\n        // Handle Object.hasOwn(obj, key)\n        CallExpression: (node) => {\n          if (\n            node.callee.type !== AST_NODE_TYPES.MemberExpression ||\n            node.callee.object.type !== AST_NODE_TYPES.Identifier ||\n            node.callee.object.name !== 'Object' ||\n            node.callee.property.type !== AST_NODE_TYPES.Identifier ||\n            node.callee.property.name !== 'hasOwn'\n          ) {\n            return;\n          }\n\n          // Check arguments: Object.hasOwn(obj, key)\n          if (node.arguments.length !== 2) return;\n\n          const objArg = node.arguments[0];\n\n          const keyArg = node.arguments[1];\n\n          if (objArg === undefined || keyArg === undefined) return;\n\n          // Type guard: ensure arguments are Expressions (not SpreadElement)\n          if (\n            objArg.type === AST_NODE_TYPES.SpreadElement ||\n            keyArg.type === AST_NODE_TYPES.SpreadElement\n          ) {\n            return;\n          }\n\n          mut_nodesToFix.push({\n            node,\n            objExpression: objArg,\n            keyExpression: keyArg,\n          });\n        },\n\n        // Handle key in obj\n        BinaryExpression: (node) => {\n          if (node.operator !== 'in') return;\n\n          const keyExpression = node.left;\n\n          const objExpression = node.right;\n\n          // Type guard: ensure keyExpression is Expression (not PrivateIdentifier)\n          if (keyExpression.type === AST_NODE_TYPES.PrivateIdentifier) return;\n\n          mut_nodesToFix.push({\n            node,\n            objExpression,\n            keyExpression,\n          });\n        },\n\n        'Program:exit': () => {\n          const namedImports = getNamedImports(tsDataForgeImport);\n\n          const hasIsRecordImport = namedImports.includes('isRecord');\n\n          const hasHasKeyImport = namedImports.includes('hasKey');\n\n          for (const [\n            index,\n            { node, objExpression, keyExpression },\n          ] of mut_nodesToFix.entries()) {\n            const objText = sourceCode.getText(objExpression);\n\n            const keyText = sourceCode.getText(keyExpression);\n\n            const originalText = sourceCode.getText(node);\n\n            context.report({\n              node,\n              messageId: 'useIsRecordAndHasKey',\n              data: {\n                original: originalText,\n                objName: objText,\n                keyName: keyText,\n              },\n              fix: (fixer) => {\n                const replacement = `(isRecord(${objText}) && hasKey(${objText}, ${keyText}))`;\n\n                const mut_importsToAdd: string[] = [];\n\n                if (!hasIsRecordImport) {\n                  mut_importsToAdd.push('isRecord');\n                }\n\n                if (!hasHasKeyImport) {\n                  mut_importsToAdd.push('hasKey');\n                }\n\n                const importFixes =\n                  index === 0 && mut_importsToAdd.length > 0\n                    ? buildImportFixes(\n                        fixer,\n                        program,\n                        tsDataForgeImport,\n                        mut_importsToAdd,\n                      )\n                    : [];\n\n                return [...importFixes, fixer.replaceText(node, replacement)];\n              },\n            });\n          }\n        },\n      };\n    },\n    defaultOptions: [],\n  } as const;\n"],"names":[],"mappings":"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"}
+{"version":3,"file":"prefer-is-record-and-has-key.mjs","sources":["../../src/rules/prefer-is-record-and-has-key.mts"],"sourcesContent":["import {\n  AST_NODE_TYPES,\n  type TSESLint,\n  type TSESTree,\n} from '@typescript-eslint/utils';\nimport { Arr } from 'ts-data-forge';\nimport * as ts from 'typescript';\nimport {\n  buildImportFixes,\n  getNamedImports,\n  getTsDataForgeImport,\n} from './import-utils.mjs';\n\ntype Options = readonly [];\n\ntype MessageIds = 'useIsRecordAndHasKey' | 'useHasKey';\n\nexport const preferIsRecordAndHasKey: TSESLint.RuleModule<MessageIds, Options> =\n  {\n    meta: {\n      type: 'suggestion',\n      docs: {\n        description:\n          'Replace `Object.hasOwn(obj, key)` or `key in obj` with `isRecord(obj) && hasKey(obj, key)` from ts-data-forge',\n      },\n      fixable: 'code',\n      schema: [],\n      messages: {\n        useIsRecordAndHasKey:\n          'Replace `{{original}}` with `isRecord({{objName}}) && hasKey({{objName}}, {{keyName}})` from ts-data-forge.',\n        useHasKey:\n          'Replace `{{original}}` with `hasKey({{objName}}, {{keyName}})` from ts-data-forge.',\n      },\n    },\n\n    create: (context) => {\n      const sourceCode = context.sourceCode;\n\n      const program = sourceCode.ast;\n\n      const tsDataForgeImport = getTsDataForgeImport(program);\n\n      const services = sourceCode.parserServices;\n\n      const checker = services?.program?.getTypeChecker();\n\n      /**\n       * Whether the `isRecord(...)` half of the rewrite would be dead code\n       * because the object already satisfies `hasKey`'s\n       * `R extends UnknownRecord` constraint. Without type information nothing\n       * is known, so the guard is kept.\n       */\n      const isKnownRecord = (\n        // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types\n        expression: TSESTree.Expression,\n      ): boolean => {\n        if (checker === undefined) return false;\n\n        const tsNode = services?.esTreeNodeToTSNodeMap?.get(expression);\n\n        return (\n          tsNode !== undefined &&\n          isAlreadyRecordType(checker, checker.getTypeAtLocation(tsNode))\n        );\n      };\n\n      const mut_nodesToFix: {\n        node: TSESTree.CallExpression | TSESTree.BinaryExpression;\n        objExpression: TSESTree.Expression;\n        keyExpression: TSESTree.Expression;\n      }[] = [];\n\n      return {\n        // Handle Object.hasOwn(obj, key)\n        CallExpression: (node) => {\n          if (\n            node.callee.type !== AST_NODE_TYPES.MemberExpression ||\n            node.callee.object.type !== AST_NODE_TYPES.Identifier ||\n            node.callee.object.name !== 'Object' ||\n            node.callee.property.type !== AST_NODE_TYPES.Identifier ||\n            node.callee.property.name !== 'hasOwn'\n          ) {\n            return;\n          }\n\n          // Check arguments: Object.hasOwn(obj, key)\n          if (node.arguments.length !== 2) return;\n\n          const objArg = node.arguments[0];\n\n          const keyArg = node.arguments[1];\n\n          if (objArg === undefined || keyArg === undefined) return;\n\n          // Type guard: ensure arguments are Expressions (not SpreadElement)\n          if (\n            objArg.type === AST_NODE_TYPES.SpreadElement ||\n            keyArg.type === AST_NODE_TYPES.SpreadElement\n          ) {\n            return;\n          }\n\n          mut_nodesToFix.push({\n            node,\n            objExpression: objArg,\n            keyExpression: keyArg,\n          });\n        },\n\n        // Handle key in obj\n        BinaryExpression: (node) => {\n          if (node.operator !== 'in') return;\n\n          const keyExpression = node.left;\n\n          const objExpression = node.right;\n\n          // Type guard: ensure keyExpression is Expression (not PrivateIdentifier)\n          if (keyExpression.type === AST_NODE_TYPES.PrivateIdentifier) return;\n\n          mut_nodesToFix.push({\n            node,\n            objExpression,\n            keyExpression,\n          });\n        },\n\n        'Program:exit': () => {\n          const namedImports = getNamedImports(tsDataForgeImport);\n\n          const rewrites = mut_nodesToFix.map((entry) => ({\n            ...entry,\n            // A record-typed object makes the `isRecord(...)` conjunct always\n            // true, so it is left out of the replacement entirely.\n            needsIsRecord: !isKnownRecord(entry.objExpression),\n          }));\n\n          const importsToAdd: readonly string[] = [\n            ...(rewrites.some(({ needsIsRecord }) => needsIsRecord) &&\n            !namedImports.includes('isRecord')\n              ? ['isRecord']\n              : []),\n            ...(namedImports.includes('hasKey') ? [] : ['hasKey']),\n          ];\n\n          for (const [\n            index,\n            { node, objExpression, keyExpression, needsIsRecord },\n          ] of rewrites.entries()) {\n            const objText = sourceCode.getText(objExpression);\n\n            const keyText = sourceCode.getText(keyExpression);\n\n            const originalText = sourceCode.getText(node);\n\n            context.report({\n              node,\n              messageId: needsIsRecord ? 'useIsRecordAndHasKey' : 'useHasKey',\n              data: {\n                original: originalText,\n                objName: objText,\n                keyName: keyText,\n              },\n              fix: (fixer) => {\n                const replacement = needsIsRecord\n                  ? `(isRecord(${objText}) && hasKey(${objText}, ${keyText}))`\n                  : `hasKey(${objText}, ${keyText})`;\n\n                // All import fixes have to live on the first report:\n                // `insertTextBefore(program, …)` produces overlapping ranges\n                // otherwise and only one of them would survive a pass.\n                const importFixes =\n                  index === 0 && importsToAdd.length > 0\n                    ? buildImportFixes(\n                        fixer,\n                        program,\n                        tsDataForgeImport,\n                        importsToAdd,\n                      )\n                    : [];\n\n                return [...importFixes, fixer.replaceText(node, replacement)];\n              },\n            });\n          }\n        },\n      };\n    },\n    defaultOptions: [],\n  } as const;\n\n/**\n * Whether `type` already satisfies `hasKey`'s `R extends UnknownRecord`\n * constraint, so that guarding the call with `isRecord` adds nothing.\n *\n * `UnknownRecord` is `ReadonlyRecord<string, unknown>`, so a string index\n * signature is exactly what it asks for and its value type is `unknown`, which\n * anything satisfies. Callables and arrays are excluded because `isRecord`\n * rejects them at runtime (`typeof fn === 'object'` is false, `Array.isArray`\n * is true), so dropping the guard there would change behavior.\n *\n * Deliberately conservative: a type TypeScript would accept through an\n * *implicit* index signature (an object type alias without one of its own)\n * keeps the guard, because the checker does not report such a signature here.\n */\nconst isAlreadyRecordType = (\n  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types\n  checker: ts.TypeChecker,\n  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types\n  type: ts.Type,\n): boolean =>\n  type.isUnion()\n    ? type.types.every((member) => isAlreadyRecordType(checker, member))\n    : checker.getIndexInfoOfType(type, ts.IndexKind.String) !== undefined &&\n      Arr.isEmpty(checker.getSignaturesOfType(type, ts.SignatureKind.Call)) &&\n      Arr.isEmpty(\n        checker.getSignaturesOfType(type, ts.SignatureKind.Construct),\n      ) &&\n      !checker.isArrayType(type) &&\n      !checker.isTupleType(type);\n"],"names":[],"mappings":"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"}

package/dist/rules/rules.d.mts

@@ -7,7 +7,7 @@ export declare const tsDataForgeRules: {
     readonly 'prefer-as-int': import("@typescript-eslint/utils/ts-eslint").RuleModule<"useBrandedNumberCastFunction", readonly [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
     readonly 'prefer-is-non-null-object': import("@typescript-eslint/utils/ts-eslint").RuleModule<"useIsNonNullObject", readonly [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
     readonly 'prefer-range-for-loop': import("@typescript-eslint/utils/ts-eslint").RuleModule<"useRangeForLoop", readonly [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
-    readonly 'prefer-is-record-and-has-key': import("@typescript-eslint/utils/ts-eslint").RuleModule<"useIsRecordAndHasKey", readonly [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
+    readonly 'prefer-is-record-and-has-key': import("@typescript-eslint/utils/ts-eslint").RuleModule<"useHasKey" | "useIsRecordAndHasKey", readonly [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
     readonly 'prefer-num-safe-parse-int': import("@typescript-eslint/utils/ts-eslint").RuleModule<"useSafeParseInt", readonly [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
     readonly 'prefer-num-safe-parse-float': import("@typescript-eslint/utils/ts-eslint").RuleModule<"useSafeParseFloat", readonly [], unknown, import("@typescript-eslint/utils/ts-eslint").RuleListener>;
     readonly 'no-unnecessary-type-guard': import("@typescript-eslint/utils/ts-eslint").RuleModule<"alwaysFalse" | "alwaysTrue" | "replaceTypeGuard", readonly [(Readonly<{

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-ts-data-forge",
-  "version": "0.3.0",
+  "version": "0.4.1",
   "private": false,
   "description": "ESLint rules that steer code toward ts-data-forge idioms.",
   "keywords": [
@@ -34,13 +34,13 @@
     "LICENSE"
   ],
   "dependencies": {
-    "@typescript-eslint/utils": "8.64.0",
-    "ts-type-forge": "^9.1.1",
-    "ts-data-forge": "14.0.0"
+    "@typescript-eslint/utils": "^8.65.0",
+    "ts-type-forge": "~9.1.1",
+    "ts-data-forge": "14.0.1"
   },
   "devDependencies": {
-    "@typescript-eslint/parser": "8.64.0",
-    "@typescript-eslint/rule-tester": "8.64.0",
+    "@typescript-eslint/parser": "8.65.0",
+    "@typescript-eslint/rule-tester": "8.65.0",
     "dedent": "1.7.2"
   },
   "peerDependencies": {

package/src/rules/no-unnecessary-type-guard.mts

@@ -44,6 +44,7 @@ type GuardSpec = DeepReadonly<
       replacements?: Record<string, string>;
     }
   | { kind: 'nonEmptyString' }
+  | { kind: 'record' }
 >;
 
 /**
@@ -98,6 +99,7 @@ const GUARD_SPECS: DeepReadonly<Record<string, GuardSpec>> = {
     replacements: NULLISH_REPLACEMENTS_EXCLUDE,
   },
   isNonEmptyString: { kind: 'nonEmptyString' },
+  isRecord: { kind: 'record' },
 } as const;
 
 const DEFERRED_OR_OPAQUE_FLAGS =
@@ -341,6 +343,20 @@ export const noUnnecessaryTypeGuard: TSESLint.RuleModule<MessageIds, Options> =
               break;
             }
 
+            case 'record': {
+              if (parts.every((p) => isGuaranteedRecord(p, checker))) {
+                // Every member already satisfies `UnknownRecord`.
+                reportConstant(node, canonicalName, true, argument);
+              } else if (
+                parts.every((p) => isGuaranteedNotRecord(p, checker))
+              ) {
+                // No member can ever be a non-null, non-array object.
+                reportConstant(node, canonicalName, false, argument);
+              }
+
+              break;
+            }
+
             case 'nonEmptyString': {
               const hasNullish =
                 inputAtoms.has('undefined') || inputAtoms.has('null');
@@ -403,6 +419,55 @@ const collectUnionParts = (type: ts.Type): readonly ts.Type[] | undefined => {
   return parts;
 };
 
+/**
+ * Whether `isRecord` is guaranteed to accept this (non-union) type.
+ *
+ * `isRecord` narrows to `UnknownRecord` (`ReadonlyRecord<string, unknown>`), so
+ * a string index signature is exactly what it asks for and its value type is
+ * `unknown`, which anything satisfies. Arrays and callables are excluded even
+ * when they carry one, because `isRecord` rejects them at runtime
+ * (`Array.isArray` is true; `typeof fn === 'object'` is false).
+ *
+ * Deliberately conservative: an object type without an index signature of its
+ * own is reported as neither guaranteed-accepted nor guaranteed-rejected, even
+ * where TypeScript would accept it through an implicit index signature.
+ */
+const isGuaranteedRecord = (
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  type: ts.Type,
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  checker: ts.TypeChecker,
+): boolean =>
+  checker.getIndexInfoOfType(type, ts.IndexKind.String) !== undefined &&
+  !isCallableType(type, checker) &&
+  !checker.isArrayType(type) &&
+  !checker.isTupleType(type);
+
+/**
+ * Whether `isRecord` is guaranteed to reject this (non-union) type: every
+ * primitive (`null` included), every array or tuple, and every callable fails
+ * its `typeof x === 'object' && x !== null && !Array.isArray(x)` check.
+ */
+const isGuaranteedNotRecord = (
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  type: ts.Type,
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  checker: ts.TypeChecker,
+): boolean =>
+  classifyAtom(type) !== 'other' ||
+  checker.isArrayType(type) ||
+  checker.isTupleType(type) ||
+  isCallableType(type, checker);
+
+const isCallableType = (
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  type: ts.Type,
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  checker: ts.TypeChecker,
+): boolean =>
+  checker.getSignaturesOfType(type, ts.SignatureKind.Call).length > 0 ||
+  checker.getSignaturesOfType(type, ts.SignatureKind.Construct).length > 0;
+
 /** Classifies a single (non-union) type into a primitive {@link Atom}. */
 // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
 const classifyAtom = (type: ts.Type): Atom => {

package/src/rules/no-unnecessary-type-guard.test.mts

@@ -20,6 +20,30 @@ const tester = new RuleTester({
 describe('no-unnecessary-type-guard', () => {
   tester.run('no-unnecessary-type-guard', noUnnecessaryTypeGuard, {
     valid: [
+      {
+        name: 'isRecord that actually narrows a union',
+        code: dedent`
+          import { isRecord } from 'ts-data-forge';
+          declare const x: Record<string, unknown> | string;
+          const y = isRecord(x);
+        `,
+      },
+      {
+        name: 'isRecord on an object type without an index signature of its own',
+        code: dedent`
+          import { isRecord } from 'ts-data-forge';
+          declare const x: Readonly<{ a: number }>;
+          const y = isRecord(x);
+        `,
+      },
+      {
+        name: 'isRecord on unknown',
+        code: dedent`
+          import { isRecord } from 'ts-data-forge';
+          declare const x: unknown;
+          const y = isRecord(x);
+        `,
+      },
       {
         name: 'isNotUndefined on a type that includes undefined',
         code: dedent`
@@ -110,6 +134,76 @@ describe('no-unnecessary-type-guard', () => {
       },
     ],
     invalid: [
+      {
+        name: 'isRecord on a record type (always true)',
+        code: dedent`
+          import { isRecord } from 'ts-data-forge';
+          declare const x: Readonly<Record<string, unknown>>;
+          const y = isRecord(x);
+        `,
+        output: dedent`
+          import { isRecord } from 'ts-data-forge';
+          declare const x: Readonly<Record<string, unknown>>;
+          const y = true;
+        `,
+        errors: [{ messageId: 'alwaysTrue' }],
+      },
+      {
+        name: 'isRecord on a union of record types (always true)',
+        code: dedent`
+          import { isRecord } from 'ts-data-forge';
+          declare const x: Record<string, number> | Record<string, string>;
+          const y = isRecord(x);
+        `,
+        output: dedent`
+          import { isRecord } from 'ts-data-forge';
+          declare const x: Record<string, number> | Record<string, string>;
+          const y = true;
+        `,
+        errors: [{ messageId: 'alwaysTrue' }],
+      },
+      {
+        name: 'isRecord on a primitive (always false)',
+        code: dedent`
+          import { isRecord } from 'ts-data-forge';
+          declare const x: string | null;
+          const y = isRecord(x);
+        `,
+        output: dedent`
+          import { isRecord } from 'ts-data-forge';
+          declare const x: string | null;
+          const y = false;
+        `,
+        errors: [{ messageId: 'alwaysFalse' }],
+      },
+      {
+        name: 'isRecord on an array (always false)',
+        code: dedent`
+          import { isRecord } from 'ts-data-forge';
+          declare const x: readonly number[];
+          const y = isRecord(x);
+        `,
+        output: dedent`
+          import { isRecord } from 'ts-data-forge';
+          declare const x: readonly number[];
+          const y = false;
+        `,
+        errors: [{ messageId: 'alwaysFalse' }],
+      },
+      {
+        name: 'isRecord on a function (always false)',
+        code: dedent`
+          import { isRecord } from 'ts-data-forge';
+          declare const x: () => void;
+          const y = isRecord(x);
+        `,
+        output: dedent`
+          import { isRecord } from 'ts-data-forge';
+          declare const x: () => void;
+          const y = false;
+        `,
+        errors: [{ messageId: 'alwaysFalse' }],
+      },
       {
         name: 'isNotUndefined on a type that cannot be undefined (always true)',
         code: dedent`

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

@@ -3,6 +3,8 @@ import {
   type TSESLint,
   type TSESTree,
 } from '@typescript-eslint/utils';
+import { Arr } from 'ts-data-forge';
+import * as ts from 'typescript';
 import {
   buildImportFixes,
   getNamedImports,
@@ -11,7 +13,7 @@ import {
 
 type Options = readonly [];
 
-type MessageIds = 'useIsRecordAndHasKey';
+type MessageIds = 'useIsRecordAndHasKey' | 'useHasKey';
 
 export const preferIsRecordAndHasKey: TSESLint.RuleModule<MessageIds, Options> =
   {
@@ -26,6 +28,8 @@ export const preferIsRecordAndHasKey: TSESLint.RuleModule<MessageIds, Options> =
       messages: {
         useIsRecordAndHasKey:
           'Replace `{{original}}` with `isRecord({{objName}}) && hasKey({{objName}}, {{keyName}})` from ts-data-forge.',
+        useHasKey:
+          'Replace `{{original}}` with `hasKey({{objName}}, {{keyName}})` from ts-data-forge.',
       },
     },
 
@@ -36,6 +40,30 @@ export const preferIsRecordAndHasKey: TSESLint.RuleModule<MessageIds, Options> =
 
       const tsDataForgeImport = getTsDataForgeImport(program);
 
+      const services = sourceCode.parserServices;
+
+      const checker = services?.program?.getTypeChecker();
+
+      /**
+       * Whether the `isRecord(...)` half of the rewrite would be dead code
+       * because the object already satisfies `hasKey`'s
+       * `R extends UnknownRecord` constraint. Without type information nothing
+       * is known, so the guard is kept.
+       */
+      const isKnownRecord = (
+        // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+        expression: TSESTree.Expression,
+      ): boolean => {
+        if (checker === undefined) return false;
+
+        const tsNode = services?.esTreeNodeToTSNodeMap?.get(expression);
+
+        return (
+          tsNode !== undefined &&
+          isAlreadyRecordType(checker, checker.getTypeAtLocation(tsNode))
+        );
+      };
+
       const mut_nodesToFix: {
         node: TSESTree.CallExpression | TSESTree.BinaryExpression;
         objExpression: TSESTree.Expression;
@@ -100,14 +128,25 @@ export const preferIsRecordAndHasKey: TSESLint.RuleModule<MessageIds, Options> =
         'Program:exit': () => {
           const namedImports = getNamedImports(tsDataForgeImport);
 
-          const hasIsRecordImport = namedImports.includes('isRecord');
-
-          const hasHasKeyImport = namedImports.includes('hasKey');
+          const rewrites = mut_nodesToFix.map((entry) => ({
+            ...entry,
+            // A record-typed object makes the `isRecord(...)` conjunct always
+            // true, so it is left out of the replacement entirely.
+            needsIsRecord: !isKnownRecord(entry.objExpression),
+          }));
+
+          const importsToAdd: readonly string[] = [
+            ...(rewrites.some(({ needsIsRecord }) => needsIsRecord) &&
+            !namedImports.includes('isRecord')
+              ? ['isRecord']
+              : []),
+            ...(namedImports.includes('hasKey') ? [] : ['hasKey']),
+          ];
 
           for (const [
             index,
-            { node, objExpression, keyExpression },
-          ] of mut_nodesToFix.entries()) {
+            { node, objExpression, keyExpression, needsIsRecord },
+          ] of rewrites.entries()) {
             const objText = sourceCode.getText(objExpression);
 
             const keyText = sourceCode.getText(keyExpression);
@@ -116,32 +155,27 @@ export const preferIsRecordAndHasKey: TSESLint.RuleModule<MessageIds, Options> =
 
             context.report({
               node,
-              messageId: 'useIsRecordAndHasKey',
+              messageId: needsIsRecord ? 'useIsRecordAndHasKey' : 'useHasKey',
               data: {
                 original: originalText,
                 objName: objText,
                 keyName: keyText,
               },
               fix: (fixer) => {
-                const replacement = `(isRecord(${objText}) && hasKey(${objText}, ${keyText}))`;
-
-                const mut_importsToAdd: string[] = [];
-
-                if (!hasIsRecordImport) {
-                  mut_importsToAdd.push('isRecord');
-                }
-
-                if (!hasHasKeyImport) {
-                  mut_importsToAdd.push('hasKey');
-                }
+                const replacement = needsIsRecord
+                  ? `(isRecord(${objText}) && hasKey(${objText}, ${keyText}))`
+                  : `hasKey(${objText}, ${keyText})`;
 
+                // All import fixes have to live on the first report:
+                // `insertTextBefore(program, …)` produces overlapping ranges
+                // otherwise and only one of them would survive a pass.
                 const importFixes =
-                  index === 0 && mut_importsToAdd.length > 0
+                  index === 0 && importsToAdd.length > 0
                     ? buildImportFixes(
                         fixer,
                         program,
                         tsDataForgeImport,
-                        mut_importsToAdd,
+                        importsToAdd,
                       )
                     : [];
 
@@ -154,3 +188,33 @@ export const preferIsRecordAndHasKey: TSESLint.RuleModule<MessageIds, Options> =
     },
     defaultOptions: [],
   } as const;
+
+/**
+ * Whether `type` already satisfies `hasKey`'s `R extends UnknownRecord`
+ * constraint, so that guarding the call with `isRecord` adds nothing.
+ *
+ * `UnknownRecord` is `ReadonlyRecord<string, unknown>`, so a string index
+ * signature is exactly what it asks for and its value type is `unknown`, which
+ * anything satisfies. Callables and arrays are excluded because `isRecord`
+ * rejects them at runtime (`typeof fn === 'object'` is false, `Array.isArray`
+ * is true), so dropping the guard there would change behavior.
+ *
+ * Deliberately conservative: a type TypeScript would accept through an
+ * *implicit* index signature (an object type alias without one of its own)
+ * keeps the guard, because the checker does not report such a signature here.
+ */
+const isAlreadyRecordType = (
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  checker: ts.TypeChecker,
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  type: ts.Type,
+): boolean =>
+  type.isUnion()
+    ? type.types.every((member) => isAlreadyRecordType(checker, member))
+    : checker.getIndexInfoOfType(type, ts.IndexKind.String) !== undefined &&
+      Arr.isEmpty(checker.getSignaturesOfType(type, ts.SignatureKind.Call)) &&
+      Arr.isEmpty(
+        checker.getSignaturesOfType(type, ts.SignatureKind.Construct),
+      ) &&
+      !checker.isArrayType(type) &&
+      !checker.isTupleType(type);

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

@@ -36,6 +36,80 @@ describe('prefer-is-record-and-has-key', () => {
       },
     ],
     invalid: [
+      {
+        name: 'drops isRecord when the object already has a string index signature',
+        code: dedent`
+          declare const obj: Readonly<Record<string, unknown>>;
+          const ok = Object.hasOwn(obj, 'a');
+        `,
+        output: dedent`
+          import { hasKey } from 'ts-data-forge';
+          declare const obj: Readonly<Record<string, unknown>>;
+          const ok = hasKey(obj, 'a');
+        `,
+        errors: [{ messageId: 'useHasKey' }],
+      },
+      {
+        name: 'drops isRecord for `key in obj` on a record-typed object',
+        code: dedent`
+          declare const obj: Record<string, number>;
+          const ok = 'a' in obj;
+        `,
+        output: dedent`
+          import { hasKey } from 'ts-data-forge';
+          declare const obj: Record<string, number>;
+          const ok = hasKey(obj, 'a');
+        `,
+        errors: [{ messageId: 'useHasKey' }],
+      },
+      {
+        name: 'keeps isRecord when only part of a union is a record',
+        code: dedent`
+          declare const obj: Record<string, unknown> | readonly unknown[];
+          const ok = Object.hasOwn(obj, 'a');
+        `,
+        output: dedent`
+          import { isRecord, hasKey } from 'ts-data-forge';
+          declare const obj: Record<string, unknown> | readonly unknown[];
+          const ok = (isRecord(obj) && hasKey(obj, 'a'));
+        `,
+        errors: [{ messageId: 'useIsRecordAndHasKey' }],
+      },
+      {
+        name: 'keeps isRecord for an index-signature-carrying callable',
+        code: dedent`
+          type Callable = { (): void; [key: string]: unknown };
+          declare const obj: Callable;
+          const ok = Object.hasOwn(obj, 'a');
+        `,
+        output: dedent`
+          import { isRecord, hasKey } from 'ts-data-forge';
+          type Callable = { (): void; [key: string]: unknown };
+          declare const obj: Callable;
+          const ok = (isRecord(obj) && hasKey(obj, 'a'));
+        `,
+        errors: [{ messageId: 'useIsRecordAndHasKey' }],
+      },
+      {
+        name: 'imports isRecord once when both forms appear in a file',
+        code: dedent`
+          declare const rec: Record<string, unknown>;
+          declare const unk: unknown;
+          const a = Object.hasOwn(rec, 'a');
+          const b = Object.hasOwn(unk, 'b');
+        `,
+        output: dedent`
+          import { isRecord, hasKey } from 'ts-data-forge';
+          declare const rec: Record<string, unknown>;
+          declare const unk: unknown;
+          const a = hasKey(rec, 'a');
+          const b = (isRecord(unk) && hasKey(unk, 'b'));
+        `,
+        errors: [
+          { messageId: 'useHasKey' },
+          { messageId: 'useIsRecordAndHasKey' },
+        ],
+      },
       {
         name: 'replaces Object.hasOwn(obj, key) with isRecord && hasKey',
         code: dedent`