@blumintinc/eslint-plugin-blumint 1.20.95 → 1.20.97

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>;

package/lib/rules/parallelize-loop-awaits.js

@@ -3,6 +3,25 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.parallelizeLoopAwaits = void 0;
 const utils_1 = require("@typescript-eslint/utils");
 const createRule_1 = require("../utils/createRule");
+// Anchored at the end of the path so multi-part suffixes such as
+// `EventRegistry.integration.test.ts` are recognized while production modules
+// that merely contain the word (`testHelpers.ts`, `latest.ts`, `contest/Thing.ts`)
+// keep their enforcement.
+const TEST_FILE_SUFFIX = /\.(test|spec)\.[cm]?[jt]sx?$/;
+// Jest convention directories hold test-only modules regardless of file name.
+const TEST_FILE_DIRECTORY = /(^|\/)(__tests__|__mocks__)\//;
+/**
+ * A test suite serves no requests and is not latency-critical, so the rule's
+ * rationale — that sequential awaits make network and I/O latency add up — does
+ * not apply to it. A loop in a suite instead replays one entrypoint to exercise
+ * behavior that accumulates across calls: each iteration must observe the state
+ * the previous iteration stored, and that state usually lives in a mock closure
+ * the loop body never names. The dependency is a side effect rather than a
+ * value, so it is invisible to every syntactic barrier below, and
+ * `Promise.all` would let all iterations observe the same initial state
+ * (issues #1395, #1687).
+ */
+const isTestFile = (filename) => TEST_FILE_SUFFIX.test(filename) || TEST_FILE_DIRECTORY.test(filename);
 const DEFAULT_COORDINATOR_PATTERNS = [
     'batchManager',
     'batch',
@@ -23,8 +42,16 @@ const defaultOptions = [
     {
         coordinatorPatterns: DEFAULT_COORDINATOR_PATTERNS,
         rateLimitedPatterns: DEFAULT_RATE_LIMITED_PATTERNS,
+        ignoreTestFiles: true,
     },
 ];
+const LOOP_NODE_TYPES = new Set([
+    utils_1.AST_NODE_TYPES.ForOfStatement,
+    utils_1.AST_NODE_TYPES.ForInStatement,
+    utils_1.AST_NODE_TYPES.ForStatement,
+    utils_1.AST_NODE_TYPES.WhileStatement,
+    utils_1.AST_NODE_TYPES.DoWhileStatement,
+]);
 exports.parallelizeLoopAwaits = (0, createRule_1.createRule)({
     name: 'parallelize-loop-awaits',
     meta: {
@@ -48,6 +75,16 @@ exports.parallelizeLoopAwaits = (0, createRule_1.createRule)({
                         items: { type: 'string' },
                         default: DEFAULT_RATE_LIMITED_PATTERNS,
                     },
+                    // Deliberately carries no schema `default`. ESLint validates rule
+                    // options with an ajv instance configured `useDefaults: true`, which
+                    // writes schema defaults INTO the supplied options object before
+                    // `defaultOptions` are merged, so a schema default here would decide
+                    // the value for every consumer who passes an options object at all.
+                    // `defaultOptions` plus the `?? true` read below is the single source
+                    // of truth.
+                    ignoreTestFiles: {
+                        type: 'boolean',
+                    },
                 },
                 additionalProperties: false,
             },
@@ -58,6 +95,14 @@ exports.parallelizeLoopAwaits = (0, createRule_1.createRule)({
     },
     defaultOptions,
     create(context, [options]) {
+        // Normalize Windows backslash separators so the forward-slash directory
+        // check matches on every platform. Without this, `getFilename()` returns
+        // `C:\repo\src\__tests__\Foo.ts` on Windows and the exemption silently
+        // fails there.
+        const filename = context.getFilename().replace(/\\/g, '/');
+        if ((options?.ignoreTestFiles ?? true) && isTestFile(filename)) {
+            return {};
+        }
         const coordinatorPatterns = options?.coordinatorPatterns ?? DEFAULT_COORDINATOR_PATTERNS;
         const rateLimitedPatterns = options?.rateLimitedPatterns ?? DEFAULT_RATE_LIMITED_PATTERNS;
         /**
@@ -72,12 +117,11 @@ exports.parallelizeLoopAwaits = (0, createRule_1.createRule)({
             return lower === pat || lower.startsWith(pat) || lower.endsWith(pat);
         }
         /**
-         * Recursively collects all identifier names referenced in a node.
-         * Does not cross nested function boundaries.
+         * Recursively collects the names a node REFERENCES. With `stopAtFunctions`
+         * the walk halts at a nested function, so a name written inside a callback
+         * describes that callback's scope rather than the surrounding loop's.
          */
         function collectIdentifiers(node, names, stopAtFunctions = false) {
-            if (stopAtFunctions && node.type !== node.type)
-                return; // no-op placeholder
             if (node.type === utils_1.AST_NODE_TYPES.Identifier) {
                 names.add(node.name);
                 return;
@@ -89,6 +133,20 @@ exports.parallelizeLoopAwaits = (0, createRule_1.createRule)({
                     node.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression)) {
                 return;
             }
+            // A non-computed property key is a label, not a reference: the `lock` in
+            // `await send({ lock: true })` names a field of the payload and binds
+            // nothing, so letting it reach the coordinator match would exempt the loop
+            // on the strength of a string. A computed key (`{ [lock]: true }`) is an
+            // expression that really does read the surrounding scope, and shorthand
+            // (`{ lock }`) carries the same identifier as its VALUE, so both keep
+            // their say. (#1688)
+            if (node.type === utils_1.AST_NODE_TYPES.Property) {
+                if (node.computed) {
+                    collectIdentifiers(node.key, names, stopAtFunctions);
+                }
+                collectIdentifiers(node.value, names, stopAtFunctions);
+                return;
+            }
             for (const key in node) {
                 if (key === 'parent' ||
                     key === 'range' ||
@@ -456,9 +514,9 @@ exports.parallelizeLoopAwaits = (0, createRule_1.createRule)({
             }
         }
         /**
-         * Walks the loop body looking for the first AwaitExpression that is NOT
-         * inside a nested async function (a different async scope). Returns the
-         * first such AwaitExpression found, or null if none exists.
+         * Walks the loop body looking for the first AwaitExpression that belongs to
+         * THIS loop — one that sits in neither a nested function nor a nested loop.
+         * Returns the first such AwaitExpression found, or null if none exists.
          */
         function findDirectAwait(node, isRoot) {
             // Do not cross into nested functions; their awaits belong to a
@@ -469,6 +527,14 @@ exports.parallelizeLoopAwaits = (0, createRule_1.createRule)({
                     node.type === utils_1.AST_NODE_TYPES.ArrowFunctionExpression)) {
                 return null;
             }
+            // An await inside a nested loop belongs to that loop, which gets its own
+            // visit and its own verdict. Claiming it here would anchor a second report
+            // on the very same await, and would judge it against the wrong body: the
+            // enclosing loop's barriers say nothing about whether the inner
+            // iterations can run together. The innermost loop owns the report. (#1688)
+            if (!isRoot && LOOP_NODE_TYPES.has(node.type)) {
+                return null;
+            }
             if (node.type === utils_1.AST_NODE_TYPES.AwaitExpression) {
                 return node;
             }
@@ -498,6 +564,135 @@ exports.parallelizeLoopAwaits = (0, createRule_1.createRule)({
             }
             return null;
         }
+        /**
+         * Reports whether a node contains a CallExpression anywhere inside it.
+         * Nested functions are deliberately traversed: a call written inside a
+         * callback in a loop clause (`items.some(() => check())`) still makes the
+         * clause's value depend on invoking something.
+         */
+        function containsCallExpression(node) {
+            if (node.type === utils_1.AST_NODE_TYPES.CallExpression) {
+                return true;
+            }
+            for (const key in node) {
+                if (key === 'parent' ||
+                    key === 'range' ||
+                    key === 'loc' ||
+                    key === 'type')
+                    continue;
+                const child = node[key];
+                if (child && typeof child === 'object') {
+                    if (Array.isArray(child)) {
+                        for (const item of child) {
+                            if (item && typeof item === 'object' && 'type' in item) {
+                                if (containsCallExpression(item))
+                                    return true;
+                            }
+                        }
+                    }
+                    else if ('type' in child) {
+                        if (containsCallExpression(child))
+                            return true;
+                    }
+                }
+            }
+            return false;
+        }
+        /**
+         * Reports whether the loop's own continuation machinery invokes a
+         * function — a call in a `while` test, or in a `for` test or update clause.
+         *
+         * Such a loop runs until an observation comes back a certain way, so the
+         * iteration count is a function of what each iteration does:
+         * `while (!hasSettled()) { await tick(); }` and
+         * `for (let i = 0; i < 100 && !findTimer(); i += 1)` both re-read state the
+         * awaited work advances. `Promise.all` has to know the iteration count up
+         * front, so there is no parallel form of these loops at all. Only the
+         * clauses re-evaluated on every iteration count; a `for` loop's `init` and a
+         * `for...of` loop's `right` run once, so a call there says nothing about
+         * cross-iteration coupling (`for (const [k, v] of map.entries())` keeps its
+         * enforcement). A `do...while` test is re-evaluated exactly like a `while`
+         * test, so it carries the same meaning. (#1687, #1688)
+         */
+        function isConditionCoupled(loopNode) {
+            if (loopNode.type === utils_1.AST_NODE_TYPES.WhileStatement ||
+                loopNode.type === utils_1.AST_NODE_TYPES.DoWhileStatement) {
+                return containsCallExpression(loopNode.test);
+            }
+            if (loopNode.type === utils_1.AST_NODE_TYPES.ForStatement) {
+                return ((!!loopNode.test && containsCallExpression(loopNode.test)) ||
+                    (!!loopNode.update && containsCallExpression(loopNode.update)));
+            }
+            return false;
+        }
+        /**
+         * Collects every identifier named in the loop's head — the `for...of`/
+         * `for...in` left and right, the `for` init, test and update, or the
+         * `while`/`do...while` test. These are the names an iteration can hand to
+         * the body.
+         */
+        function collectLoopHeadIdentifiers(loopNode) {
+            const names = new Set();
+            const clauses = loopNode.type === utils_1.AST_NODE_TYPES.ForStatement
+                ? [loopNode.init, loopNode.test, loopNode.update]
+                : loopNode.type === utils_1.AST_NODE_TYPES.WhileStatement ||
+                    loopNode.type === utils_1.AST_NODE_TYPES.DoWhileStatement
+                    ? [loopNode.test]
+                    : [loopNode.left, loopNode.right];
+            for (const clause of clauses) {
+                if (clause)
+                    collectIdentifiers(clause, names, false);
+            }
+            return names;
+        }
+        /**
+         * Reports whether the loop body is a single discarded `await` of a call
+         * that consumes nothing the iteration produces, e.g.
+         * `for (let i = 0; i < 21; i += 1) { await postSuggestion(); }`.
+         *
+         * Such a loop passes nothing from the iteration into the call and keeps
+         * nothing the call returns, so the only reason to write it is an ordered
+         * side effect the callee owns — replaying one entrypoint so each run
+         * observes what the previous run stored. Every barrier below reads syntax
+         * inside the body, and this body has none to read: no assignment, no
+         * binding, no control flow, and no identifier but the callee. Reporting it
+         * would be a verdict passed on zero evidence, and the plugin prefers a
+         * false negative to a false positive.
+         *
+         * A call that names anything from the loop head is excluded, because that
+         * name IS the evidence: `for (const doc of snap.docs) { await
+         * doc.ref.delete(); }` takes no arguments either, yet each iteration
+         * addresses its own document and the loop is exactly the shape the rule
+         * exists to flag. (#1687)
+         */
+        function isBareDiscardedZeroArgCall(loopNode) {
+            const { body } = loopNode;
+            const statements = body.type === utils_1.AST_NODE_TYPES.BlockStatement ? body.body : [body];
+            if (statements.length !== 1)
+                return false;
+            const [statement] = statements;
+            if (statement.type !== utils_1.AST_NODE_TYPES.ExpressionStatement)
+                return false;
+            if (statement.expression.type !== utils_1.AST_NODE_TYPES.AwaitExpression) {
+                return false;
+            }
+            const { argument } = statement.expression;
+            const callExpr = argument.type === utils_1.AST_NODE_TYPES.ChainExpression
+                ? argument.expression
+                : argument;
+            if (callExpr.type !== utils_1.AST_NODE_TYPES.CallExpression ||
+                callExpr.arguments.length !== 0) {
+                return false;
+            }
+            const headNames = collectLoopHeadIdentifiers(loopNode);
+            const callNames = new Set();
+            collectIdentifiers(callExpr, callNames, false);
+            for (const name of callNames) {
+                if (headNames.has(name))
+                    return false;
+            }
+            return true;
+        }
         /**
          * Central analysis for a loop node. Returns the AwaitExpression to
          * report on, or null if the loop should not be flagged.
@@ -506,6 +701,21 @@ exports.parallelizeLoopAwaits = (0, createRule_1.createRule)({
             const body = loopNode.body;
             if (!body)
                 return null;
+            // Exclusion: `for await (const x of stream)` consumes an async iterable,
+            // which the language pulls one value at a time; the sequencing is the
+            // construct's meaning rather than an oversight.
+            if (loopNode.type === utils_1.AST_NODE_TYPES.ForOfStatement &&
+                loopNode.await === true) {
+                return null;
+            }
+            // Exclusion: the loop's continuation condition or update invokes a
+            // function, so how many iterations run depends on what they do
+            if (isConditionCoupled(loopNode))
+                return null;
+            // Exclusion: the body is a lone discarded await of a zero-argument call,
+            // which carries no evidence either way
+            if (isBareDiscardedZeroArgCall(loopNode))
+                return null;
             // Find an await directly inside the loop body (not in nested async fns)
             const awaitExpr = findDirectAwait(body, true);
             if (!awaitExpr)
@@ -539,43 +749,23 @@ exports.parallelizeLoopAwaits = (0, createRule_1.createRule)({
             }
             return awaitExpr;
         }
+        function checkLoop(loopNode) {
+            const awaitExpr = analyzeLoop(loopNode);
+            if (awaitExpr) {
+                context.report({
+                    node: awaitExpr,
+                    messageId: 'parallelizeLoopAwaits',
+                });
+            }
+        }
         return {
-            ForOfStatement(node) {
-                const awaitExpr = analyzeLoop(node);
-                if (awaitExpr) {
-                    context.report({
-                        node: awaitExpr,
-                        messageId: 'parallelizeLoopAwaits',
-                    });
-                }
-            },
-            ForInStatement(node) {
-                const awaitExpr = analyzeLoop(node);
-                if (awaitExpr) {
-                    context.report({
-                        node: awaitExpr,
-                        messageId: 'parallelizeLoopAwaits',
-                    });
-                }
-            },
-            ForStatement(node) {
-                const awaitExpr = analyzeLoop(node);
-                if (awaitExpr) {
-                    context.report({
-                        node: awaitExpr,
-                        messageId: 'parallelizeLoopAwaits',
-                    });
-                }
-            },
-            WhileStatement(node) {
-                const awaitExpr = analyzeLoop(node);
-                if (awaitExpr) {
-                    context.report({
-                        node: awaitExpr,
-                        messageId: 'parallelizeLoopAwaits',
-                    });
-                }
-            },
+            ForOfStatement: checkLoop,
+            ForInStatement: checkLoop,
+            ForStatement: checkLoop,
+            WhileStatement: checkLoop,
+            // A `do...while` repeats one body per iteration exactly as the other four
+            // forms do; it is the same target and earns the same analysis. (#1688)
+            DoWhileStatement: checkLoop,
         };
     },
 });

package/lib/rules/prefer-getter-over-parameterless-method.d.ts

@@ -1,3 +1,4 @@
+import { TSESLint } from '@typescript-eslint/utils';
 type OptionShape = {
     stripPrefixes?: string[];
     ignoredMethods?: string[];
@@ -10,5 +11,5 @@ type OptionShape = {
 };
 type Options = [OptionShape];
 type MessageIds = 'preferGetter' | 'preferGetterSideEffect';
-export declare const preferGetterOverParameterlessMethod: import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleModule<MessageIds, Options, import("@typescript-eslint/utils/dist/ts-eslint/Rule").RuleListener>;
+export declare const preferGetterOverParameterlessMethod: TSESLint.RuleModule<MessageIds, Options, TSESLint.RuleListener>;
 export default preferGetterOverParameterlessMethod;