@blumintinc/eslint-plugin-blumint 1.20.94 → 1.20.96

package/lib/rules/no-always-true-false-conditions.js

@@ -30,6 +30,28 @@ exports.noAlwaysTrueFalseConditions = (0, createRule_1.createRule)({
         const evaluatedParentNodes = new Set();
         // Sentinel distinguishes "no const literal resolved" from valid literal values (including null/undefined)
         const NOT_FOUND = Symbol('literal-not-found');
+        const ASSERTION_EXPRESSION_TYPES = new Set([
+            utils_1.AST_NODE_TYPES.TSAsExpression,
+            utils_1.AST_NODE_TYPES.TSSatisfiesExpression,
+            utils_1.AST_NODE_TYPES.TSNonNullExpression,
+            utils_1.AST_NODE_TYPES.TSTypeAssertion,
+        ]);
+        /**
+         * Strips type/non-null assertions from an expression. An assertion only
+         * describes a value, so the value behind it is exactly as knowable as the
+         * value itself — `"a" as const` is *more* certain than `"a"`, never less.
+         * Every resolution site strips them, otherwise a wrapper silently retires
+         * detection: sibling fixers add `as const` to module-scope constants, so a
+         * resolver that stopped at the wrapper would go blind on each constant they
+         * touch.
+         */
+        function unwrapAssertions(node) {
+            let current = node;
+            while (ASSERTION_EXPRESSION_TYPES.has(current.type)) {
+                current = current.expression;
+            }
+            return current;
+        }
         /**
          * Walks the current scope chain to locate a variable by name so identifier
          * lookups can resolve const initializers even when declared in parent scopes.
@@ -71,11 +93,74 @@ exports.noAlwaysTrueFalseConditions = (0, createRule_1.createRule)({
                 return NOT_FOUND;
             }
             const initializer = definition.node.init;
-            if (initializer?.type === utils_1.AST_NODE_TYPES.Literal) {
-                return initializer.value;
+            if (!initializer) {
+                return NOT_FOUND;
+            }
+            const value = unwrapAssertions(initializer);
+            if (value.type === utils_1.AST_NODE_TYPES.Literal) {
+                return value.value;
             }
             return NOT_FOUND;
         }
+        /**
+         * A const binding freezes the binding, not the object it points at, so a
+         * resolved object literal only stays constant while every reference merely
+         * reads a property off it. Writing through a member expression, or handing
+         * the object to anything that can retain and mutate it, makes the property
+         * values unknowable from the declaration alone.
+         */
+        function isPropertyReadReference(reference) {
+            const { identifier } = reference;
+            const parent = identifier.parent;
+            if (!parent) {
+                return false;
+            }
+            // The declaration's own initialization write.
+            if (parent.type === utils_1.AST_NODE_TYPES.VariableDeclarator &&
+                parent.id === identifier) {
+                return true;
+            }
+            if (parent.type !== utils_1.AST_NODE_TYPES.MemberExpression ||
+                parent.object !== identifier) {
+                return false;
+            }
+            const access = parent.parent?.type === utils_1.AST_NODE_TYPES.ChainExpression
+                ? parent.parent.parent
+                : parent.parent;
+            if (!access) {
+                return true;
+            }
+            const writesTheProperty = (access.type === utils_1.AST_NODE_TYPES.AssignmentExpression &&
+                access.left === parent) ||
+                access.type === utils_1.AST_NODE_TYPES.UpdateExpression ||
+                (access.type === utils_1.AST_NODE_TYPES.UnaryExpression &&
+                    access.operator === 'delete');
+            return !writesTheProperty;
+        }
+        /**
+         * Resolves an identifier to the object literal it is initialized with when
+         * declared as a const nothing can mutate. Returns undefined whenever the
+         * binding is absent, is not a const, is initialized with anything other
+         * than an object literal, or escapes to code that could rewrite it.
+         */
+        function resolveIdentifierObject(identifier) {
+            const variable = findVariableInScopes(identifier.name);
+            if (!variable) {
+                return undefined;
+            }
+            const definition = findConstIdentifierDefinition(variable, identifier.name);
+            if (!definition?.node.init) {
+                return undefined;
+            }
+            const initializer = unwrapAssertions(definition.node.init);
+            if (initializer.type !== utils_1.AST_NODE_TYPES.ObjectExpression) {
+                return undefined;
+            }
+            if (!variable.references.every(isPropertyReadReference)) {
+                return undefined;
+            }
+            return initializer;
+        }
         /**
          * Checks if a literal value is always truthy or falsy
          */
@@ -95,6 +180,117 @@ exports.noAlwaysTrueFalseConditions = (0, createRule_1.createRule)({
                     return {};
             }
         }
+        /**
+         * Classifies an expression that a constant declaration binds, so a resolved
+         * property value is judged by what it is rather than by where it was found.
+         * Anything whose value depends on runtime state stays unresolved.
+         */
+        function checkConstantValue(node) {
+            const value = unwrapAssertions(node);
+            switch (value.type) {
+                case utils_1.AST_NODE_TYPES.Literal:
+                    // A regex literal is an object, and its `value` is unusable when the
+                    // linting runtime cannot construct the pattern.
+                    return 'regex' in value
+                        ? { isTruthy: true }
+                        : checkLiteralValue(value);
+                case utils_1.AST_NODE_TYPES.ObjectExpression:
+                case utils_1.AST_NODE_TYPES.ArrayExpression:
+                case utils_1.AST_NODE_TYPES.ArrowFunctionExpression:
+                case utils_1.AST_NODE_TYPES.FunctionExpression:
+                case utils_1.AST_NODE_TYPES.ClassExpression:
+                    return { isTruthy: true };
+                case utils_1.AST_NODE_TYPES.TemplateLiteral:
+                    return value.expressions.length === 0
+                        ? value.quasis[0].value.raw === ''
+                            ? { isFalsy: true }
+                            : { isTruthy: true }
+                        : {};
+                default:
+                    return {};
+            }
+        }
+        /**
+         * Reads the property name a member expression accesses. Returns undefined
+         * when the key is computed from something other than a literal, since the
+         * accessed property is then unknown at lint time.
+         */
+        function memberPropertyName(member) {
+            if (member.computed) {
+                const key = unwrapAssertions(member.property);
+                return key.type === utils_1.AST_NODE_TYPES.Literal &&
+                    (typeof key.value === 'string' || typeof key.value === 'number')
+                    ? String(key.value)
+                    : undefined;
+            }
+            return member.property.type === utils_1.AST_NODE_TYPES.Identifier
+                ? member.property.name
+                : undefined;
+        }
+        /**
+         * Reads the key an object literal property declares, mirroring the member
+         * access side so both are compared as strings.
+         */
+        function propertyKeyName(property) {
+            const { key } = property;
+            if (key.type === utils_1.AST_NODE_TYPES.Literal &&
+                (typeof key.value === 'string' || typeof key.value === 'number')) {
+                return String(key.value);
+            }
+            return !property.computed && key.type === utils_1.AST_NODE_TYPES.Identifier
+                ? key.name
+                : undefined;
+        }
+        /**
+         * Evaluates a property read against a resolved object literal. The result
+         * stays empty whenever the literal's shape hides the answer — a spread, a
+         * key computed at runtime, an accessor — and whenever the property is
+         * absent, because a missing own property can still resolve through the
+         * prototype chain (`config.toString`) or through declaration merging.
+         */
+        function checkObjectPropertyAccess(objectExpression, member) {
+            const propertyName = memberPropertyName(member);
+            if (propertyName === undefined) {
+                return {};
+            }
+            let resolvedValue;
+            for (const property of objectExpression.properties) {
+                if (property.type !== utils_1.AST_NODE_TYPES.Property) {
+                    // A spread can contribute or overwrite any key.
+                    return {};
+                }
+                const keyName = propertyKeyName(property);
+                if (keyName === undefined) {
+                    return {};
+                }
+                if (keyName === propertyName) {
+                    if (property.kind !== 'init') {
+                        // An accessor returns whatever it likes.
+                        return {};
+                    }
+                    // A later duplicate key wins.
+                    resolvedValue = property.value;
+                }
+            }
+            return resolvedValue ? checkConstantValue(resolvedValue) : {};
+        }
+        /**
+         * Evaluates a member access whose object the rule can pin to an object
+         * literal, whether the literal is written inline or reached through a const
+         * binding. Optional chaining off such an object behaves like plain access,
+         * because the object is known not to be nullish.
+         */
+        function checkMemberAccess(member) {
+            const object = unwrapAssertions(member.object);
+            if (object.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
+                return checkObjectPropertyAccess(object, member);
+            }
+            if (object.type === utils_1.AST_NODE_TYPES.Identifier) {
+                const resolved = resolveIdentifierObject(object);
+                return resolved ? checkObjectPropertyAccess(resolved, member) : {};
+            }
+            return {};
+        }
         const MATH_FOLDABLE_METHODS = new Set(['max', 'min']);
         /**
          * Resolves a `Math.max`/`Math.min` call over numeric literals to the number
@@ -130,11 +326,12 @@ exports.noAlwaysTrueFalseConditions = (0, createRule_1.createRule)({
          * Returns undefined when the operand depends on runtime values.
          */
         function resolveNumericOperand(node) {
-            if (node.type === utils_1.AST_NODE_TYPES.Literal &&
-                typeof node.value === 'number') {
-                return node.value;
+            const operand = unwrapAssertions(node);
+            if (operand.type === utils_1.AST_NODE_TYPES.Literal &&
+                typeof operand.value === 'number') {
+                return operand.value;
             }
-            return evaluateMathMinMaxCall(node);
+            return evaluateMathMinMaxCall(operand);
         }
         function compareNumericValues(leftValue, operator, rightValue) {
             switch (operator) {
@@ -172,13 +369,16 @@ exports.noAlwaysTrueFalseConditions = (0, createRule_1.createRule)({
          * Checks if a binary expression with literals is always truthy or falsy
          */
         function checkBinaryExpression(node) {
+            // An assertion around an operand leaves the compared value untouched.
+            const left = unwrapAssertions(node.left);
+            const right = unwrapAssertions(node.right);
             // Check for bitwise operations
             if (node.operator === '&') {
-                if (node.left.type === utils_1.AST_NODE_TYPES.Literal &&
-                    node.right.type === utils_1.AST_NODE_TYPES.Literal &&
-                    typeof node.left.value === 'number' &&
-                    typeof node.right.value === 'number') {
-                    const result = node.left.value & node.right.value;
+                if (left.type === utils_1.AST_NODE_TYPES.Literal &&
+                    right.type === utils_1.AST_NODE_TYPES.Literal &&
+                    typeof left.value === 'number' &&
+                    typeof right.value === 'number') {
+                    const result = left.value & right.value;
                     if (result === 0) {
                         return { isFalsy: true };
                     }
@@ -190,17 +390,17 @@ exports.noAlwaysTrueFalseConditions = (0, createRule_1.createRule)({
             // A non-literal operand can still be a compile-time constant, so resolve
             // it before abandoning the comparison. Bailing out unconditionally here
             // hid every folded-call comparison (Math.max(1, 2) === 0) from the rule.
-            if (node.left.type !== utils_1.AST_NODE_TYPES.Literal ||
-                node.right.type !== utils_1.AST_NODE_TYPES.Literal) {
-                const resolvedLeft = resolveNumericOperand(node.left);
-                const resolvedRight = resolveNumericOperand(node.right);
+            if (left.type !== utils_1.AST_NODE_TYPES.Literal ||
+                right.type !== utils_1.AST_NODE_TYPES.Literal) {
+                const resolvedLeft = resolveNumericOperand(left);
+                const resolvedRight = resolveNumericOperand(right);
                 if (resolvedLeft === undefined || resolvedRight === undefined) {
                     return {};
                 }
                 return compareNumericValues(resolvedLeft, node.operator, resolvedRight);
             }
-            const leftValue = node.left.value;
-            const rightValue = node.right.value;
+            const leftValue = left.value;
+            const rightValue = right.value;
             // Skip if either value is null or undefined
             if (leftValue === null ||
                 leftValue === undefined ||
@@ -376,15 +576,6 @@ exports.noAlwaysTrueFalseConditions = (0, createRule_1.createRule)({
             }
             return {};
         }
-        /**
-         * Check if a node is an "as const" expression
-         */
-        function isAsConstExpression(node) {
-            return (node.type === utils_1.AST_NODE_TYPES.TSAsExpression &&
-                node.typeAnnotation.type === utils_1.AST_NODE_TYPES.TSTypeReference &&
-                node.typeAnnotation.typeName.type === utils_1.AST_NODE_TYPES.Identifier &&
-                node.typeAnnotation.typeName.name === 'const');
-        }
         /**
          * Check if a logical expression is being used for default value assignment
          * This includes patterns like:
@@ -870,6 +1061,11 @@ exports.noAlwaysTrueFalseConditions = (0, createRule_1.createRule)({
             if (evaluatedParentNodes.has(node)) {
                 return {};
             }
+            // An assertion wrapper carries the same value as the expression inside it
+            const unwrapped = unwrapAssertions(node);
+            if (unwrapped !== node) {
+                return evaluateConstantExpression(unwrapped);
+            }
             // Check special constants and identifiers first
             const specialResult = checkSpecialValues(node);
             if (specialResult.isTruthy || specialResult.isFalsy) {
@@ -950,11 +1146,6 @@ exports.noAlwaysTrueFalseConditions = (0, createRule_1.createRule)({
                     return { isFalsy: true };
                 }
             }
-            // "as const" expressions
-            if (isAsConstExpression(node) &&
-                node.expression.type === utils_1.AST_NODE_TYPES.Literal) {
-                return checkLiteralValue(node.expression);
-            }
             // Special checks for const variables in tests
             if (node.type === utils_1.AST_NODE_TYPES.BinaryExpression) {
                 if (node.left.type === utils_1.AST_NODE_TYPES.Identifier &&
@@ -1056,38 +1247,16 @@ exports.noAlwaysTrueFalseConditions = (0, createRule_1.createRule)({
                     return evaluateConstantExpression(logicalNode.left);
                 }
             }
-            // Handle optional chaining with literal objects
+            // Optional chaining off an object the rule can pin to an object literal.
+            // The guard the operator adds is dead there, and the property it reads is
+            // as knowable as the literal that declares it, whatever the binding and
+            // the property are named. Anything else — a binding initialized from a
+            // call, a parameter, a value that may legitimately be undefined — stays
+            // unresolved.
             if (node.type === utils_1.AST_NODE_TYPES.ChainExpression &&
-                node.expression.type === utils_1.AST_NODE_TYPES.MemberExpression) {
-                if (node.expression.optional) {
-                    // Handle object?.prop
-                    if (
-                    // Only consider it always truthy if it's a literal object expression
-                    node.expression.object.type === utils_1.AST_NODE_TYPES.ObjectExpression) {
-                        // If we have a property access and we know the object is a literal object
-                        return { isTruthy: true };
-                    }
-                    // Special case for identifiers that are explicitly defined in the same scope
-                    // This is to handle test cases like `const obj = { prop: "value" }; if (obj?.prop) {}`
-                    if (node.expression.object.type === utils_1.AST_NODE_TYPES.Identifier &&
-                        node.expression.object.name === 'obj' &&
-                        node.expression.property.type === utils_1.AST_NODE_TYPES.Identifier &&
-                        node.expression.property.name === 'prop') {
-                        // This is specifically for the test case "obj?.prop"
-                        return { isTruthy: true };
-                    }
-                    // Special case for array length checks with optional chaining
-                    // This handles cases like `filtered?.length` where filtered could be undefined
-                    if (node.expression.property.type === utils_1.AST_NODE_TYPES.Identifier &&
-                        node.expression.property.name === 'length') {
-                        // For array length checks with optional chaining, we can't determine
-                        // if the condition is always truthy or falsy, so return empty result
-                        return {};
-                    }
-                    // For other cases like arrays, identifiers, etc., we can't determine
-                    // if the condition is always truthy or falsy, so return empty result
-                    return {};
-                }
+                node.expression.type === utils_1.AST_NODE_TYPES.MemberExpression &&
+                node.expression.optional) {
+                return checkMemberAccess(node.expression);
             }
             // Handle Object.keys().length
             if (node.type === utils_1.AST_NODE_TYPES.BinaryExpression &&

package/lib/rules/no-redundant-param-types.js

@@ -3,6 +3,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.noRedundantParamTypes = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
+const disableDirectives_1 = require("../utils/disableDirectives");
 const importRemoval_1 = require("../utils/importRemoval");
 /**
  * The annotation a parameter carries, or `undefined` when it has none. A
@@ -68,57 +69,88 @@ exports.noRedundantParamTypes = (0, createRule_1.createRule)({
     create(context) {
         const sourceCode = context.getSourceCode();
         /**
-         * Reports a parameter annotation, taking with it any import it was the only
+         * An annotation is stripped together with any import it was the only
          * consumer of. The two are one fix: applying either half alone leaves the
          * file worse than applying neither — a stripped annotation with its import
          * left behind fails `no-unused-vars`, and since this rule's own report is
          * resolved by the fix, nothing re-reports the debt.
          *
-         * Orphanhood is judged against this one annotation's own removal and the
-         * file as it stands, never against what the rest of the `--fix` run might
-         * also delete. A sibling annotation naming the same type may be
-         * `eslint-disable`d — which a rule cannot see, since suppression is applied
-         * to reports after they are emitted — so an edit that assumes its sibling
-         * will also go deletes an import the surviving annotation still references,
-         * trading an unused import for a dangling type. Judging one edit at a time
-         * is suppression-safe by construction: a suppressed report's fix never
-         * applies, so it can never have been depended on.
+         * Reporting is therefore deferred to `Program:exit`: an import is unbound
+         * only once no reference to it survives the fix, and a file where two
+         * annotations name the same imported type strips both in a single pass.
+         * Judging each removal alone sees the sibling annotation still standing,
+         * concludes the binding is alive, and leaves the import stranded with no
+         * later pass to notice.
+         */
+        const sites = [];
+        /**
+         * Suppression is applied to reports after a rule emits them, so a suppressed
+         * site keeps its annotation while losing its fix. Counting its removal
+         * toward orphanhood would unbind an import the surviving text still spells,
+         * trading an unused import for a dangling type.
+         */
+        const isReportSuppressed = (0, disableDirectives_1.createSuppressionChecker)(context);
+        /**
+         * The strips that actually ship. A site is excluded when its report will be
+         * suppressed, or when its own removal orphans something the helper cannot
+         * rewrite — a local alias, an interface, a type parameter. Deleting a
+         * declaration is a materially riskier edit than dropping an import
+         * specifier, and the author is better placed to decide whether the type
+         * should go or be used elsewhere.
          *
-         * The cost is that a type shared by several strippable annotations is not
-         * unbound in a single pass; each pass removes the annotations it can see,
-         * and only a pass that leaves the binding with no reference at all removes
-         * the import.
+         * Screening individually before batching keeps one unfixable site from
+         * vetoing the rest: orphanhood grows monotonically with the removed set, so
+         * a site that cannot be planned alone can only ever poison the batch.
          */
-        function reportParam(param, typeAnnotation) {
-            const removal = annotationRemovalRange(typeAnnotation, sourceCode);
-            const importRanges = (0, importRemoval_1.planOrphanedImportRemoval)(sourceCode, [removal]);
-            context.report({
-                node: param,
-                messageId: 'redundantParamType',
-                data: {
-                    paramText: sourceCode.getText(param).replace(/\s+/g, ' ').trim(),
-                },
-                // No plan means no binding can be unbound safely, so the annotation
-                // stays too: the report without a fixer is the lesser damage.
-                ...(importRanges
-                    ? {
-                        fix: (fixer) => [
-                            fixer.removeRange([removal[0], removal[1]]),
-                            ...importRanges.map((range) => fixer.removeRange([range[0], range[1]])),
-                        ],
-                    }
-                    : {}),
-            });
+        function selectFixableSites() {
+            return sites.filter((site) => !isReportSuppressed(site.param) &&
+                (0, importRemoval_1.planOrphanedImportRemoval)(sourceCode, [site.removal]) !== null);
         }
         return {
+            'Program:exit'() {
+                if (sites.length === 0)
+                    return;
+                const fixable = selectFixableSites();
+                const removals = fixable.map((site) => site.removal);
+                // One plan over every surviving strip: an import referenced solely by
+                // annotations that all go in this pass is orphaned by their union, even
+                // though no single one of them orphans it.
+                const importRanges = removals.length > 0
+                    ? (0, importRemoval_1.planOrphanedImportRemoval)(sourceCode, removals)
+                    : null;
+                // The whole batch ships as one fix, so no strip can land without the
+                // others that the import's orphanhood was judged against. The rest
+                // report without a fixer; the carrier's pass already resolves them.
+                //
+                // No plan at all means no binding can be unbound safely, so every
+                // annotation stays: reports without a fixer are the lesser damage.
+                const carrier = importRanges ? fixable[0] : undefined;
+                for (const site of sites) {
+                    context.report({
+                        node: site.param,
+                        messageId: 'redundantParamType',
+                        data: { paramText: site.paramText },
+                        fix: site === carrier && importRanges
+                            ? (fixer) => [
+                                ...removals.map((range) => fixer.removeRange([range[0], range[1]])),
+                                ...importRanges.map((range) => fixer.removeRange([range[0], range[1]])),
+                            ]
+                            : null,
+                    });
+                }
+            },
             ArrowFunctionExpression(node) {
                 if (!hasRedundantTypeAnnotation(node))
                     return;
                 node.params.forEach((param) => {
                     const typeAnnotation = annotationOf(param);
-                    if (typeAnnotation) {
-                        reportParam(param, typeAnnotation);
-                    }
+                    if (!typeAnnotation)
+                        return;
+                    sites.push({
+                        param,
+                        removal: annotationRemovalRange(typeAnnotation, sourceCode),
+                        paramText: sourceCode.getText(param).replace(/\s+/g, ' ').trim(),
+                    });
                 });
             },
         };

package/lib/rules/no-unnecessary-verb-suffix.js

@@ -439,11 +439,7 @@ function contractCoversName(typeName, memberName, index, visited) {
     }
     const alias = index.typeAliases.get(typeName);
     if (alias) {
-        // An alias to anything but a type literal (an intersection, a mapped type,
-        // a reference to an imported type) hides its member list from a syntactic
-        // reader, so it is treated as unreadable.
-        return (alias.typeAnnotation.type !== utils_1.AST_NODE_TYPES.TSTypeLiteral ||
-            membersDeclareName(alias.typeAnnotation.members, memberName));
+        return aliasCoversName(alias.typeAnnotation, memberName, index, visited);
     }
     const classDeclaration = index.classes.get(typeName);
     if (classDeclaration) {
@@ -454,6 +450,57 @@ function contractCoversName(typeName, memberName, index, visited) {
     // and its members are unreadable here.
     return true;
 }
+/**
+ * Reports whether the type an alias names accounts for `memberName`.
+ *
+ * A type literal lists its members outright. An intersection is readable as far
+ * as its constituents are, which matters because `prefer-type-over-interface`
+ * ships in the same recommended config and rewrites
+ * `interface S extends Base { … }` to `type S = Base & { … }` by `--fix`:
+ * treating every non-literal alias as unreadable would let that sibling fix
+ * retire the member check for every contract written as an interface with a
+ * heritage clause (#1679). Anything else — a union, a mapped or conditional
+ * type, a reference whose target lives in another module — hides its member
+ * list from a syntactic reader and stays unreadable, so the member keeps its
+ * exemption.
+ */
+function aliasCoversName(typeNode, memberName, index, visited) {
+    switch (typeNode.type) {
+        case utils_1.AST_NODE_TYPES.TSTypeLiteral:
+            return membersDeclareName(typeNode.members, memberName);
+        case utils_1.AST_NODE_TYPES.TSIntersectionType:
+            return intersectionCoversName(typeNode, memberName, index, visited);
+        default:
+            return true;
+    }
+}
+/**
+ * Reports whether an intersection accounts for `memberName`. An intersection
+ * contributes every member of every constituent, so one constituent declaring
+ * the name settles the question — and a constituent whose members cannot be
+ * read settles it too, in the exempting direction: the name may well be that
+ * hidden part's, and this plugin prefers a false negative over a false positive
+ * (#1350). The member is only left to the class author when every constituent
+ * is readable and none of them declares it.
+ */
+function intersectionCoversName(intersection, memberName, index, visited) {
+    return intersection.types.some((constituent) => constituentCoversName(constituent, memberName, index, visited));
+}
+/**
+ * Answers `intersectionCoversName` for one constituent. A reference is followed
+ * through the file's declarations by the same resolver a heritage clause uses,
+ * so a contract split across a local base and an inline literal reads as a
+ * whole; a reference the file does not declare, and a qualified or otherwise
+ * opaque constituent, count as unreadable.
+ */
+function constituentCoversName(typeNode, memberName, index, visited) {
+    if (typeNode.type === utils_1.AST_NODE_TYPES.TSTypeReference) {
+        return typeNode.typeName.type === utils_1.AST_NODE_TYPES.Identifier
+            ? contractCoversName(typeNode.typeName.name, memberName, index, visited)
+            : true;
+    }
+    return aliasCoversName(typeNode, memberName, index, visited);
+}
 function heritageCoversName(heritage, memberName, index, visited) {
     return heritage.some((clause) => {
         const typeName = heritageTypeName(clause.expression);

package/lib/rules/parallelize-loop-awaits.d.ts

@@ -2,6 +2,7 @@ type Options = [
     {
         coordinatorPatterns?: string[];
         rateLimitedPatterns?: string[];
+        ignoreTestFiles?: boolean;
     }
 ];
 export declare const parallelizeLoopAwaits: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<"parallelizeLoopAwaits", Options, import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;