eslint-plugin-ts-std-forge 0.1.7 → 0.1.9

package/dist/rules/prefer-safe-number-parse.mjs

@@ -1,7 +1,8 @@
 import { AST_NODE_TYPES, } from '@typescript-eslint/utils';
+import { buildNamedImportFix, getArgumentText, getImportDeclarations, getNamedImports, skipTypeWrappers, } from 'eslint-rule-forge';
 import * as ts from 'typescript';
-import { getArgumentText, getValueType, isIdentifierNamed, skipTypeWrappers, } from './ast-utils.mjs';
-import { buildImportFixes, getNamedImports, getTsStdForgeImport, } from './import-utils.mjs';
+import { isIdentifierNamed, typeHoldsAtEveryLayer } from './ast-utils.mjs';
+import { TS_STD_FORGE_MODULE } from './constants.mjs';
 
 
 
@@ -42,7 +43,7 @@ export const preferSafeNumberParse = {
     create: (context) => {
         const sourceCode = context.sourceCode;
         const program = sourceCode.ast;
-        const tsStdForgeImport = getTsStdForgeImport(program);
+        const tsStdForgeImports = getImportDeclarations(program, TS_STD_FORGE_MODULE);
         const mut_nodesToFix = [];
         return {
             CallExpression: (node) => {
@@ -74,14 +75,15 @@ export const preferSafeNumberParse = {
 
 
 
-                const argType = getValueType(sourceCode, firstArg);
-                if (argType === undefined || !isStringType(argType)) {
+
+
+                if (!typeHoldsAtEveryLayer(sourceCode, firstArg, isStringType)) {
                     return;
                 }
                 mut_nodesToFix.push({ node, argExpression: firstArg });
             },
             'Program:exit': () => {
-                const namedImports = getNamedImports(tsStdForgeImport);
+                const namedImports = getNamedImports(tsStdForgeImports);
                 const missingImports = ['Result', 'SafeNumber'].filter((name) => !namedImports.includes(name));
                 for (const [index, { node, argExpression },] of mut_nodesToFix.entries()) {
                     const argText = getArgumentText(sourceCode, argExpression);
@@ -95,7 +97,7 @@ export const preferSafeNumberParse = {
                         fix: (fixer) => {
                             const core = `Result.unwrapOkOr(SafeNumber.parse(${argText}), Number.NaN)`;
                             const importFixes = index === 0 && missingImports.length > 0
-                                ? buildImportFixes(fixer, program, missingImports)
+                                ? buildNamedImportFix(fixer, program, TS_STD_FORGE_MODULE, missingImports)
                                 : [];
                             return [...importFixes, fixer.replaceText(node, core)];
                         },

package/dist/rules/prefer-safe-number-parse.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"prefer-safe-number-parse.mjs","sourceRoot":"","sources":["../../src/rules/prefer-safe-number-parse.mts"],"names":[],"mappings":"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"}
+{"version":3,"file":"prefer-safe-number-parse.mjs","sourceRoot":"","sources":["../../src/rules/prefer-safe-number-parse.mts"],"names":[],"mappings":"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"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint-plugin-ts-std-forge",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "private": false,
   "description": "ESLint rules that steer code toward ts-std-forge idioms.",
   "keywords": [
@@ -35,6 +35,7 @@
   ],
   "dependencies": {
     "@typescript-eslint/utils": "^8.71.1",
+    "eslint-rule-forge": "^0.1.0",
     "ts-std-forge": "0.5.1",
     "ts-type-forge": "~9.2.2"
   },
@@ -42,9 +43,9 @@
     "@typescript-eslint/parser": "8.71.1",
     "@typescript-eslint/rule-tester": "8.71.1",
     "dedent": "1.7.2",
-    "eslint-config-typed": "5.17.3",
-    "eslint-plugin-ts-fortress": "1.3.2",
-    "eslint-plugin-ts-type-forge": "0.8.7",
+    "eslint-config-typed": "5.18.0",
+    "eslint-plugin-ts-fortress": "1.3.3",
+    "eslint-plugin-ts-type-forge": "0.8.8",
     "prettier": "3.9.9",
     "prettier-plugin-organize-imports": "4.3.0",
     "prettier-plugin-packagejson": "3.0.2",

package/src/rule-types.mts

@@ -5,6 +5,7 @@
 
 import type { Linter } from 'eslint';
 import { expectType } from 'ts-std-forge';
+import type { ReadonlyRecord } from 'ts-type-forge';
 import type { tsStdForgeRules } from './rules/index.mjs';
 
 /**
@@ -106,7 +107,7 @@ export type EslintTsStdForgeRules = Readonly<{
   'ts-std-forge/prefer-safe-number-parse-integer': PreferSafeNumberParseInteger.RuleEntry;
 }>;
 
-export type EslintTsStdForgeRulesOption = Readonly<{}>;
+export type EslintTsStdForgeRulesOption = ReadonlyRecord<never, never>;
 
 // If this assertion fails to type-check, this generated file has drifted from
 // the actual plugin rules — re-run `pnpm run gen:rule-types`.

package/src/rules/ast-utils.mts

@@ -1,33 +1,11 @@
 import {
   AST_NODE_TYPES,
-  ASTUtils,
   type TSESLint,
   type TSESTree,
 } from '@typescript-eslint/utils';
+import { skipTypeWrappers, typeWrapperLayers } from 'eslint-rule-forge';
 import type * as ts from 'typescript';
 
-/**
- * `node` with every `as`, `satisfies`, `!` and `<T>` around it taken off: the
- * expression whose value it is. Judge syntax and ask types on what this
- * returns, so that a wrapper neither hides a pattern (`xs.length > (0 as
- * const)`) nor vouches for a type (`Number(b as unknown as string)`, whose
- * value is still a boolean), and keep the original node for fix text. See
- * `docs/writing-lint-rules.md` at the repository root.
- *
- * A copy of the helper in `eslint-config-typed`, which this package, published
- * on its own, cannot import.
- */
-export const skipTypeWrappers = (
-  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-  node: TSESTree.Node,
-): TSESTree.Node =>
-  isTypeWrapper(node) ? skipTypeWrappers(node.expression) : node;
-
-export const isTypeWrapper = (
-  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-  node: TSESTree.Node,
-): node is TypeWrapper => TYPE_WRAPPERS.has(node.type);
-
 /**
  * Whether `node`, read through its type wrappers, is the identifier `name`:
  * `Number`, `(Number as NumberConstructor)` and `Number!` are the same object.
@@ -44,104 +22,36 @@ export const isIdentifierNamed = (
   );
 };
 
-export type TypeWrapper =
-  | TSESTree.TSAsExpression
-  | TSESTree.TSNonNullExpression
-  | TSESTree.TSSatisfiesExpression
-  | TSESTree.TSTypeAssertion;
-
 /**
- * The type of the value `node` evaluates to, asked of the expression inside
- * its type wrappers rather than of the cast, or `undefined` without type
- * information. A `!` among the wrappers still takes `null` and `undefined`
- * out, since that much the source asserts about the value itself.
+ * Whether `holds` is true of the type of every layer of type wrappers around
+ * `node` (see {@link typeWrapperLayers}), outermost to innermost; `false`
+ * without type information. A widening cast (`s as string | number`) is the
+ * author saying the value may be more than it is, and is respected; a
+ * narrowing one (`s!`, `v as unknown as string`) cannot vouch for what the
+ * value's own type does not, and the fix, which keeps the wrapper, has to
+ * type-check at every layer too.
  */
-export const getValueType = (
+export const typeHoldsAtEveryLayer = (
   // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
   sourceCode: TSESLint.SourceCode,
   // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
   node: TSESTree.Node,
-): ts.Type | undefined => {
+  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
+  holds: (type: ts.Type, typeChecker: ts.TypeChecker) => boolean,
+): boolean => {
   const services = sourceCode.parserServices;
 
   const checker = services?.program?.getTypeChecker();
 
-  const tsNode = services?.esTreeNodeToTSNodeMap?.get(skipTypeWrappers(node));
-
-  if (checker === undefined || tsNode === undefined) {
-    return undefined;
+  if (checker === undefined) {
+    return false;
   }
 
-  const type = checker.getTypeAtLocation(tsNode);
+  return typeWrapperLayers(node).every((layer) => {
+    const tsNode = services?.esTreeNodeToTSNodeMap?.get(layer);
 
-  return hasNonNullAssertion(node) ? checker.getNonNullableType(type) : type;
+    return (
+      tsNode !== undefined && holds(checker.getTypeAtLocation(tsNode), checker)
+    );
+  });
 };
-
-/**
- * The source text of `node` to put in a call's argument list. `getText`
- * leaves out the parentheses the source puts around a node, and a sequence
- * `(a, b)` without them would be read as two arguments.
- */
-export const getArgumentText = (
-  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-  sourceCode: TSESLint.SourceCode,
-  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-  node: TSESTree.Node,
-): string => {
-  const text = sourceCode.getText(node);
-
-  return node.type === AST_NODE_TYPES.SequenceExpression ? `(${text})` : text;
-};
-
-/**
- * The range of `node` together with the parentheses the source puts around it,
- * which `node.range` leaves out: all of `((Array.isArray))` for the member
- * expression inside.
- */
-export const getRangeWithParens = (
-  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-  sourceCode: TSESLint.SourceCode,
-  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-  node: TSESTree.Node,
-): TSESTree.Range => {
-  const depth = parenthesesDepth(sourceCode, node);
-
-  if (depth === 0) {
-    return node.range;
-  }
-
-  const opening = sourceCode.getTokenBefore(node, { skip: depth - 1 });
-
-  const closing = sourceCode.getTokenAfter(node, { skip: depth - 1 });
-
-  return opening === null || closing === null
-    ? node.range
-    : [opening.range[0], closing.range[1]];
-};
-
-/** How many pairs of parentheses the source puts around `node`. */
-const parenthesesDepth = (
-  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-  sourceCode: TSESLint.SourceCode,
-  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-  node: TSESTree.Node,
-  depth: number = 0,
-): number =>
-  ASTUtils.isParenthesized(depth + 1, node, sourceCode)
-    ? parenthesesDepth(sourceCode, node, depth + 1)
-    : depth;
-
-const hasNonNullAssertion = (
-  // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
-  node: TSESTree.Node,
-): boolean =>
-  isTypeWrapper(node) &&
-  (node.type === AST_NODE_TYPES.TSNonNullExpression ||
-    hasNonNullAssertion(node.expression));
-
-const TYPE_WRAPPERS: ReadonlySet<AST_NODE_TYPES> = new Set([
-  AST_NODE_TYPES.TSAsExpression,
-  AST_NODE_TYPES.TSNonNullExpression,
-  AST_NODE_TYPES.TSSatisfiesExpression,
-  AST_NODE_TYPES.TSTypeAssertion,
-]);

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

@@ -3,12 +3,13 @@ import {
   type TSESLint,
   type TSESTree,
 } from '@typescript-eslint/utils';
-import { skipTypeWrappers } from './ast-utils.mjs';
 import {
-  buildImportFixes,
+  buildNamedImportFix,
+  getImportDeclarations,
   getNamedImports,
-  getTsStdForgeImport,
-} from './import-utils.mjs';
+  skipTypeWrappers,
+} from 'eslint-rule-forge';
+import { TS_STD_FORGE_MODULE } from './constants.mjs';
 
 type Options = readonly [];
 
@@ -34,7 +35,10 @@ export const preferIsNonNullObject: TSESLint.RuleModule<MessageIds, Options> = {
 
     const program = sourceCode.ast;
 
-    const tsStdForgeImport = getTsStdForgeImport(program);
+    const tsStdForgeImports = getImportDeclarations(
+      program,
+      TS_STD_FORGE_MODULE,
+    );
 
     const mut_nodesToFix: {
       node: TSESTree.LogicalExpression;
@@ -53,7 +57,7 @@ export const preferIsNonNullObject: TSESLint.RuleModule<MessageIds, Options> = {
       },
       'Program:exit': () => {
         const hasIsNonNullObjectImport =
-          getNamedImports(tsStdForgeImport).includes('isNonNullObject');
+          getNamedImports(tsStdForgeImports).includes('isNonNullObject');
 
         // The import fix lives on the first report only:
         // `insertTextBefore(program, …)` produces overlapping ranges
@@ -72,7 +76,9 @@ export const preferIsNonNullObject: TSESLint.RuleModule<MessageIds, Options> = {
 
               const importFixes =
                 index === 0 && !hasIsNonNullObjectImport
-                  ? buildImportFixes(fixer, program, ['isNonNullObject'])
+                  ? buildNamedImportFix(fixer, program, TS_STD_FORGE_MODULE, [
+                      'isNonNullObject',
+                    ])
                   : [];
 
               return [...importFixes, fixer.replaceText(node, replacement)];

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

@@ -3,19 +3,17 @@ import {
   type TSESLint,
   type TSESTree,
 } from '@typescript-eslint/utils';
-import { SafeArray } from 'ts-std-forge';
-import * as ts from 'typescript';
 import {
+  buildNamedImportFix,
   getArgumentText,
-  getValueType,
-  isIdentifierNamed,
-  skipTypeWrappers,
-} from './ast-utils.mjs';
-import {
-  buildImportFixes,
+  getImportDeclarations,
   getNamedImports,
-  getTsStdForgeImport,
-} from './import-utils.mjs';
+  skipTypeWrappers,
+} from 'eslint-rule-forge';
+import { SafeArray } from 'ts-std-forge';
+import * as ts from 'typescript';
+import { isIdentifierNamed, typeHoldsAtEveryLayer } from './ast-utils.mjs';
+import { TS_STD_FORGE_MODULE } from './constants.mjs';
 
 type Options = readonly [];
 
@@ -44,29 +42,27 @@ export const preferIsRecordAndHasKey: TSESLint.RuleModule<MessageIds, Options> =
 
       const program = sourceCode.ast;
 
-      const tsStdForgeImport = getTsStdForgeImport(program);
-
-      const checker = sourceCode.parserServices?.program?.getTypeChecker();
+      const tsStdForgeImports = getImportDeclarations(
+        program,
+        TS_STD_FORGE_MODULE,
+      );
 
       /**
        * 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. The type is the value's, not a cast's:
-       * an array cast to a record is still rejected by `isRecord`.
+       * `R extends UnknownRecord` constraint, at every layer of type
+       * wrappers: an array cast to a record is still rejected by `isRecord`,
+       * and a record widened to one that may be an array is the author saying
+       * it may need the guard. 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 type = getValueType(sourceCode, expression);
-
-        return type !== undefined && isAlreadyRecordType(checker, type);
-      };
+      ): boolean =>
+        typeHoldsAtEveryLayer(sourceCode, expression, (type, checker) =>
+          isAlreadyRecordType(checker, type),
+        );
 
       const mut_nodesToFix: {
         node: TSESTree.CallExpression | TSESTree.BinaryExpression;
@@ -139,7 +135,7 @@ export const preferIsRecordAndHasKey: TSESLint.RuleModule<MessageIds, Options> =
         },
 
         'Program:exit': () => {
-          const namedImports = getNamedImports(tsStdForgeImport);
+          const namedImports = getNamedImports(tsStdForgeImports);
 
           const rewrites = mut_nodesToFix.map((entry) => ({
             ...entry,
@@ -184,7 +180,12 @@ export const preferIsRecordAndHasKey: TSESLint.RuleModule<MessageIds, Options> =
                 // otherwise and only one of them would survive a pass.
                 const importFixes =
                   index === 0 && importsToAdd.length > 0
-                    ? buildImportFixes(fixer, program, importsToAdd)
+                    ? buildNamedImportFix(
+                        fixer,
+                        program,
+                        TS_STD_FORGE_MODULE,
+                        importsToAdd,
+                      )
                     : [];
 
                 return [...importFixes, fixer.replaceText(node, replacement)];

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

@@ -125,15 +125,42 @@ describe('prefer-is-record-and-has-key through type wrappers', () => {
         errors: [{ messageId: 'useHasKey' }],
       },
       {
-        name: 'reads `!` on an optional record as the record it asserts',
+        // `Object.hasOwn(undefined, 'a')` throws; `isRecord` answers false.
+        name: 'keeps isRecord for `!` on an optional record, which leaves undefined in place',
         code: dedent`
           declare const obj: Readonly<Record<string, unknown>> | undefined;
           const ok = Object.hasOwn(obj!, 'a');
         `,
         output: dedent`
-          import { hasKey } from 'ts-std-forge';
+          import { isRecord, hasKey } from 'ts-std-forge';
           declare const obj: Readonly<Record<string, unknown>> | undefined;
-          const ok = hasKey(obj!, 'a');
+          const ok = (isRecord(obj!) && hasKey(obj!, 'a'));
+        `,
+        errors: [{ messageId: 'useIsRecordAndHasKey' }],
+      },
+      {
+        name: 'keeps isRecord for a record widened by `as` to one that may be an array',
+        code: dedent`
+          declare const obj: Readonly<Record<string, unknown>>;
+          const ok = Object.hasOwn(obj as Readonly<Record<string, unknown>> | readonly string[], 'a');
+        `,
+        output: dedent`
+          import { isRecord, hasKey } from 'ts-std-forge';
+          declare const obj: Readonly<Record<string, unknown>>;
+          const ok = (isRecord(obj as Readonly<Record<string, unknown>> | readonly string[]) && hasKey(obj as Readonly<Record<string, unknown>> | readonly string[], 'a'));
+        `,
+        errors: [{ messageId: 'useIsRecordAndHasKey' }],
+      },
+      {
+        name: 'drops isRecord for a record that is a record at every layer',
+        code: dedent`
+          declare const obj: Readonly<Record<string, unknown>>;
+          const ok = Object.hasOwn(obj! as Readonly<Record<string, unknown>>, 'a');
+        `,
+        output: dedent`
+          import { hasKey } from 'ts-std-forge';
+          declare const obj: Readonly<Record<string, unknown>>;
+          const ok = hasKey(obj! as Readonly<Record<string, unknown>>, 'a');
         `,
         errors: [{ messageId: 'useHasKey' }],
       },

package/src/rules/prefer-safe-array-is-array.mts

@@ -4,15 +4,14 @@ import {
   type TSESTree,
 } from '@typescript-eslint/utils';
 import {
+  buildNamedImportFix,
+  getImportDeclarations,
+  getNamedImports,
   getRangeWithParens,
-  isIdentifierNamed,
   skipTypeWrappers,
-} from './ast-utils.mjs';
-import {
-  buildImportFixes,
-  getNamedImports,
-  getTsStdForgeImport,
-} from './import-utils.mjs';
+} from 'eslint-rule-forge';
+import { isIdentifierNamed } from './ast-utils.mjs';
+import { TS_STD_FORGE_MODULE } from './constants.mjs';
 
 type Options = readonly [];
 
@@ -39,7 +38,10 @@ export const preferSafeArrayIsArray: TSESLint.RuleModule<MessageIds, Options> =
 
       const program = sourceCode.ast;
 
-      const tsStdForgeImport = getTsStdForgeImport(program);
+      const tsStdForgeImports = getImportDeclarations(
+        program,
+        TS_STD_FORGE_MODULE,
+      );
 
       const mut_nodesToFix: TSESTree.CallExpression[] = [];
 
@@ -53,7 +55,7 @@ export const preferSafeArrayIsArray: TSESLint.RuleModule<MessageIds, Options> =
         },
         'Program:exit': () => {
           const hasSafeArrayImport =
-            getNamedImports(tsStdForgeImport).includes('SafeArray');
+            getNamedImports(tsStdForgeImports).includes('SafeArray');
 
           // The import fix lives on the first report only:
           // `insertTextBefore(program, …)` produces overlapping ranges
@@ -67,7 +69,9 @@ export const preferSafeArrayIsArray: TSESLint.RuleModule<MessageIds, Options> =
               fix: (fixer) => {
                 const importFixes =
                   index === 0 && !hasSafeArrayImport
-                    ? buildImportFixes(fixer, program, ['SafeArray'])
+                    ? buildNamedImportFix(fixer, program, TS_STD_FORGE_MODULE, [
+                        'SafeArray',
+                      ])
                     : [];
 
                 // Only the callee is replaced, type wrappers included, along

package/src/rules/prefer-safe-array-is-array.test.mts

@@ -45,6 +45,20 @@ ruleTester.run('prefer-safe-array-is-array', preferSafeArrayIsArray, {
       `,
       errors: [{ messageId: 'useSafeArrayIsArray' }],
     },
+    {
+      name: 'Sees SafeArray imported by a second ts-std-forge declaration',
+      code: dedent`
+        import type { Result } from 'ts-std-forge';
+        import { SafeArray } from 'ts-std-forge';
+        const result = Array.isArray(value);
+      `,
+      output: dedent`
+        import type { Result } from 'ts-std-forge';
+        import { SafeArray } from 'ts-std-forge';
+        const result = SafeArray.isArray(value);
+      `,
+      errors: [{ messageId: 'useSafeArrayIsArray' }],
+    },
     {
       name: 'Replace multiple Array.isArray calls, importing once',
       code: dedent`

package/src/rules/prefer-safe-array-length-guard.mts

@@ -3,17 +3,16 @@ import {
   type TSESLint,
   type TSESTree,
 } from '@typescript-eslint/utils';
-import type { ReadonlyRecord } from 'ts-type-forge';
 import {
+  buildNamedImportFix,
   getArgumentText,
-  getValueType,
-  skipTypeWrappers,
-} from './ast-utils.mjs';
-import {
-  buildImportFixes,
+  getImportDeclarations,
   getNamedImports,
-  getTsStdForgeImport,
-} from './import-utils.mjs';
+  skipTypeWrappers,
+} from 'eslint-rule-forge';
+import type { ReadonlyRecord } from 'ts-type-forge';
+import { typeHoldsAtEveryLayer } from './ast-utils.mjs';
+import { TS_STD_FORGE_MODULE } from './constants.mjs';
 
 type Options = readonly [];
 
@@ -82,31 +81,29 @@ export const preferSafeArrayLengthGuard: TSESLint.RuleModule<
 
     const program = sourceCode.ast;
 
-    const tsStdForgeImport = getTsStdForgeImport(program);
-
-    const checker = sourceCode.parserServices?.program?.getTypeChecker();
+    const tsStdForgeImports = getImportDeclarations(
+      program,
+      TS_STD_FORGE_MODULE,
+    );
 
     /**
      * Whether `expression` is an array or tuple. Without type information the
      * answer is no: `.length` is also a string's, a function's and a
-     * `TypedArray`'s, and none of those can be handed to the guard. The type is
-     * the value's, not a cast's: a string cast to an array is still a string.
+     * `TypedArray`'s, and none of those can be handed to the guard. It has to
+     * be one at every layer of type wrappers: a string cast to an array is
+     * still a string, and the fix, which keeps the wrapper, hands the guard
+     * the type the outermost layer states.
      */
     const isArrayLike = (
       // eslint-disable-next-line @typescript-eslint/prefer-readonly-parameter-types
       expression: TSESTree.Expression,
-    ): boolean => {
-      if (checker === undefined) {
-        return false;
-      }
-
-      const type = getValueType(sourceCode, expression);
-
-      return (
-        type !== undefined &&
-        (checker.isArrayType(type) || checker.isTupleType(type))
+    ): boolean =>
+      typeHoldsAtEveryLayer(
+        sourceCode,
+        expression,
+        (type, checker) =>
+          checker.isArrayType(type) || checker.isTupleType(type),
       );
-    };
 
     const mut_nodesToFix: {
       node: TSESTree.BinaryExpression;
@@ -130,7 +127,7 @@ export const preferSafeArrayLengthGuard: TSESLint.RuleModule<
       },
       'Program:exit': () => {
         const hasSafeArrayImport =
-          getNamedImports(tsStdForgeImport).includes('SafeArray');
+          getNamedImports(tsStdForgeImports).includes('SafeArray');
 
         // The import fix lives on the first report only:
         // `insertTextBefore(program, …)` produces overlapping ranges
@@ -155,7 +152,9 @@ export const preferSafeArrayLengthGuard: TSESLint.RuleModule<
 
               const importFixes =
                 index === 0 && !hasSafeArrayImport
-                  ? buildImportFixes(fixer, program, ['SafeArray'])
+                  ? buildNamedImportFix(fixer, program, TS_STD_FORGE_MODULE, [
+                      'SafeArray',
+                    ])
                   : [];
 
               return [...importFixes, fixer.replaceText(node, replacement)];