@blumintinc/eslint-plugin-blumint 1.20.94 → 1.20.96

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;

package/lib/rules/prefer-getter-over-parameterless-method.js

@@ -152,6 +152,232 @@ function hasOverloadSignatures(node) {
         return !hasBody && key.name === targetName;
     });
 }
+function getClassOf(node) {
+    const classBody = node.parent;
+    if (!classBody || classBody.type !== utils_1.AST_NODE_TYPES.ClassBody) {
+        return null;
+    }
+    const classNode = classBody.parent;
+    if (classNode &&
+        (classNode.type === utils_1.AST_NODE_TYPES.ClassDeclaration ||
+            classNode.type === utils_1.AST_NODE_TYPES.ClassExpression)) {
+        return classNode;
+    }
+    return null;
+}
+/**
+ * A member typed as a function is as binding as a method signature: a getter
+ * returning the function's *result* is not assignable to the function type, so
+ * such a member is a contract match too.
+ */
+function isFunctionTypeNode(node) {
+    if (!node)
+        return false;
+    switch (node.type) {
+        case utils_1.AST_NODE_TYPES.TSFunctionType:
+        case utils_1.AST_NODE_TYPES.TSConstructorType:
+            return true;
+        case utils_1.AST_NODE_TYPES.TSUnionType:
+        case utils_1.AST_NODE_TYPES.TSIntersectionType:
+            return node.types.some(isFunctionTypeNode);
+        default:
+            return false;
+    }
+}
+function knownMemberName(key, computed) {
+    if (!key || computed)
+        return null;
+    if (key.type === utils_1.AST_NODE_TYPES.Identifier)
+        return key.name;
+    if (key.type === utils_1.AST_NODE_TYPES.Literal && typeof key.value === 'string') {
+        return key.value;
+    }
+    return null;
+}
+function findVariableInScopeChain(scope, name) {
+    let current = scope;
+    while (current) {
+        const variable = current.variables.find((entry) => entry.name === name);
+        if (variable) {
+            return variable;
+        }
+        current = current.upper;
+    }
+    return null;
+}
+function collectTypeElementMembers(elements, out) {
+    for (const element of elements) {
+        if (element.type === utils_1.AST_NODE_TYPES.TSMethodSignature) {
+            // A `get`/`set` signature already describes property access, so a getter
+            // implementation satisfies it — only call signatures bind.
+            if (element.kind === 'get' || element.kind === 'set')
+                continue;
+            const name = knownMemberName(element.key, element.computed);
+            if (name)
+                out.instance.add(name);
+            continue;
+        }
+        if (element.type === utils_1.AST_NODE_TYPES.TSPropertySignature &&
+            isFunctionTypeNode(element.typeAnnotation?.typeAnnotation)) {
+            const name = knownMemberName(element.key, element.computed);
+            if (name)
+                out.instance.add(name);
+        }
+    }
+}
+function collectClassContractMembers(classNode, out) {
+    for (const member of classNode.body.body) {
+        if (member.type === utils_1.AST_NODE_TYPES.StaticBlock)
+            continue;
+        const isStatic = member.static ?? false;
+        const target = isStatic ? out.staticSide : out.instance;
+        if (member.type === utils_1.AST_NODE_TYPES.MethodDefinition ||
+            member.type === utils_1.AST_NODE_TYPES.TSAbstractMethodDefinition) {
+            if (member.kind !== 'method')
+                continue;
+            const name = knownMemberName(member.key, member.computed);
+            if (name)
+                target.add(name);
+            continue;
+        }
+        if ((member.type === utils_1.AST_NODE_TYPES.PropertyDefinition ||
+            member.type === utils_1.AST_NODE_TYPES.TSAbstractPropertyDefinition) &&
+            isFunctionTypeNode(member.typeAnnotation?.typeAnnotation)) {
+            const name = knownMemberName(member.key, member.computed);
+            if (name)
+                target.add(name);
+        }
+    }
+}
+function collectContractFromName(name, scope, seen, out) {
+    if (seen.has(name))
+        return;
+    seen.add(name);
+    const variable = findVariableInScopeChain(scope, name);
+    // No binding at all (a global/ambient type) or a binding with no declaration
+    // node (a lib type) leaves the contract unknowable from this file.
+    if (!variable || variable.defs.length === 0) {
+        out.resolved = false;
+        return;
+    }
+    for (const def of variable.defs) {
+        const declaration = def.node;
+        switch (declaration.type) {
+            case utils_1.AST_NODE_TYPES.TSInterfaceDeclaration:
+                collectContractFromInterface(declaration, scope, seen, out);
+                break;
+            case utils_1.AST_NODE_TYPES.TSTypeAliasDeclaration:
+                collectContractFromTypeNode(declaration.typeAnnotation, scope, seen, out);
+                break;
+            case utils_1.AST_NODE_TYPES.ClassDeclaration:
+            case utils_1.AST_NODE_TYPES.ClassExpression:
+                collectContractFromClass(declaration, scope, seen, out);
+                break;
+            default:
+                // An import binding, an enum, a value — nothing whose members this file
+                // can enumerate.
+                out.resolved = false;
+        }
+    }
+}
+function collectContractFromHeritage(heritage, scope, seen, out) {
+    // A qualified reference (`ns.Type`) names a declaration this lookup cannot
+    // reach, so the contract stays unresolved.
+    if (heritage.expression.type !== utils_1.AST_NODE_TYPES.Identifier) {
+        out.resolved = false;
+        return;
+    }
+    collectContractFromName(heritage.expression.name, scope, seen, out);
+}
+function collectContractFromInterface(declaration, scope, seen, out) {
+    collectTypeElementMembers(declaration.body.body, out);
+    for (const heritage of [
+        ...(declaration.extends ?? []),
+        ...(declaration.implements ?? []),
+    ]) {
+        collectContractFromHeritage(heritage, scope, seen, out);
+    }
+}
+function collectContractFromClass(declaration, scope, seen, out) {
+    collectClassContractMembers(declaration, out);
+    if (declaration.superClass) {
+        if (declaration.superClass.type === utils_1.AST_NODE_TYPES.Identifier) {
+            collectContractFromName(declaration.superClass.name, scope, seen, out);
+        }
+        else {
+            // A mixin call or member expression base class: unknowable members.
+            out.resolved = false;
+        }
+    }
+    for (const heritage of declaration.implements ?? []) {
+        collectContractFromHeritage(heritage, scope, seen, out);
+    }
+}
+function collectContractFromTypeNode(typeNode, scope, seen, out) {
+    switch (typeNode.type) {
+        case utils_1.AST_NODE_TYPES.TSTypeLiteral:
+            collectTypeElementMembers(typeNode.members, out);
+            return;
+        case utils_1.AST_NODE_TYPES.TSIntersectionType:
+            for (const part of typeNode.types) {
+                collectContractFromTypeNode(part, scope, seen, out);
+            }
+            return;
+        case utils_1.AST_NODE_TYPES.TSTypeReference:
+            if (typeNode.typeName.type === utils_1.AST_NODE_TYPES.Identifier) {
+                collectContractFromName(typeNode.typeName.name, scope, seen, out);
+                return;
+            }
+            out.resolved = false;
+            return;
+        default:
+            // Mapped, conditional, indexed-access and utility-type shapes describe
+            // members this rule cannot enumerate syntactically.
+            out.resolved = false;
+    }
+}
+/**
+ * Resolves what the class's `extends`/`implements` clauses oblige its members
+ * to look like, using only declarations visible in the file being linted.
+ */
+function resolveHeritageContract(classNode, scope) {
+    const heritageNames = [];
+    let hasOpaqueHeritage = false;
+    if (classNode.superClass) {
+        if (classNode.superClass.type === utils_1.AST_NODE_TYPES.Identifier) {
+            heritageNames.push(classNode.superClass.name);
+        }
+        else {
+            hasOpaqueHeritage = true;
+        }
+    }
+    for (const implemented of classNode.implements ?? []) {
+        if (implemented.expression.type === utils_1.AST_NODE_TYPES.Identifier) {
+            heritageNames.push(implemented.expression.name);
+        }
+        else {
+            hasOpaqueHeritage = true;
+        }
+    }
+    if (!heritageNames.length && !hasOpaqueHeritage) {
+        return { status: 'none' };
+    }
+    if (hasOpaqueHeritage) {
+        return { status: 'unresolvable' };
+    }
+    const members = {
+        instance: new Set(),
+        staticSide: new Set(),
+        resolved: true,
+    };
+    const seen = new Set();
+    for (const name of heritageNames) {
+        collectContractFromName(name, scope, seen, members);
+    }
+    return members.resolved
+        ? { status: 'resolved', members }
+        : { status: 'unresolvable' };
+}
 exports.preferGetterOverParameterlessMethod = (0, createRule_1.createRule)({
     name: 'prefer-getter-over-parameterless-method',
     meta: {
@@ -535,6 +761,37 @@ exports.preferGetterOverParameterlessMethod = (0, createRule_1.createRule)({
                 }
             }
         }
+        const heritageContracts = new WeakMap();
+        /**
+         * A method that satisfies an `implements` clause or overrides a base-class
+         * member cannot become a getter: the heritage type declares a *method*, so
+         * the conversion the rule prescribes is a TS2416/TS2417 compile error. When
+         * every heritage reference resolves in-file the exemption is per method —
+         * only names the contract declares are spared. When any reference leaves
+         * the file (an import, a global, a third-party `.d.ts`, a mixin call) the
+         * contract's members are unknowable, so no method of that class can be
+         * proven safe and the whole class is spared: a false negative is preferable
+         * to prescribing a remedy that does not compile.
+         */
+        function isConstrainedByHeritage(node) {
+            const classNode = getClassOf(node);
+            if (!classNode)
+                return false;
+            let contract = heritageContracts.get(classNode);
+            if (!contract) {
+                contract = resolveHeritageContract(classNode, context.getScope());
+                heritageContracts.set(classNode, contract);
+            }
+            if (contract.status === 'none')
+                return false;
+            if (contract.status === 'unresolvable')
+                return true;
+            const name = node.key.name;
+            const isStatic = node.static ?? false;
+            return isStatic
+                ? contract.members.staticSide.has(name)
+                : contract.members.instance.has(name);
+        }
         const callUsedNamesByClass = new WeakMap();
         const callUsedNamesInFile = new Set();
         const candidates = [];
@@ -594,6 +851,8 @@ exports.preferGetterOverParameterlessMethod = (0, createRule_1.createRule)({
                     return;
                 if (!node.value.body)
                     return;
+                if (isConstrainedByHeritage(node))
+                    return;
                 const name = node.key.name;
                 if (ignoredMethods.has(name))
                     return;