eslint-plugin-test-governance 0.13.0 → 0.13.2

package/dist/utils/analyze.js

@@ -32,14 +32,16 @@ export function directiveOf(comment) {
     return { kind, rules, description: { separator: separator.index, start: separator.index + separator[0].length } };
 }
 // A call at the start of a comment line, as `test('...'`, `test.describe.skip(` or `await test.step(`. Code has
-// no space before a call's `(`, and a sentence such as `// it (see above) ...` has one.
-const COMMENTED_CALL_RE = /^(\s*\*?\s*)(?:await\s+)?([A-Za-z_$][\w$]*)(?:\.[A-Za-z_$][\w$]*)*\(/;
+// no space before a call's `(`, and a sentence such as `// it (see above) ...` has one. An empty call, as
+// `test.skip()`, changes a test at runtime and declares none.
+const COMMENTED_CALL_RE = /^(\s*\*?\s*)(?:await\s+)?([A-Za-z_$][\w$]*)((?:\.[A-Za-z_$][\w$]*)*)\((?!\))/;
 /**
  * Blocks of comments that hold a test or describe written out as code: comments on consecutive lines with
- * no code before them, one of whose lines starts with a call of `names`. A JSDoc comment is documentation,
- * so a test in its example doesn't count.
+ * no code before them, one of whose lines starts with a call of `names` whose members all declare tests,
+ * as `test.describe.skip(`, unlike `test.use(`. A JSDoc comment is documentation, so a test in its example
+ * doesn't count.
  */
-function findCommentedOutTests(sourceCode, comments, names, states) {
+function findCommentedOutTests(sourceCode, comments, names, members, states) {
     const blocks = [];
     for (const comment of comments) {
         if (sourceCode.getTokenBefore(comment)?.loc.end.line === comment.loc.start.line)
@@ -59,7 +61,13 @@ function findCommentedOutTests(sourceCode, comments, names, states) {
             .flatMap(commentLines)
             .flatMap(({ text, start }) => {
             const match = COMMENTED_CALL_RE.exec(text);
-            return match && names.has(match[2]) ? [[start + match[1].length, start + text.trimEnd().length]] : [];
+            const declares = match !== null &&
+                names.has(match[2]) &&
+                match[3]
+                    .split('.')
+                    .slice(1)
+                    .every((member) => members.has(member));
+            return declares ? [[start + match[1].length, start + text.trimEnd().length]] : [];
         })
             .at(0);
         if (range === undefined)
@@ -92,14 +100,16 @@ function disableRegions(comments, states) {
 /** The names a parameter gives to runtime info: `testInfo`, or `skip` in `({ skip }) => ...`. */
 function infoNames(param, methods, step) {
     if (param?.type === 'Identifier')
-        return [{ name: param.name, methods, step }];
+        return [{ name: param.name, binding: param, methods, step }];
     if (param?.type !== 'ObjectPattern')
         return [];
     return param.properties.flatMap((prop) => {
         if (prop.type !== 'Property' || prop.value.type !== 'Identifier')
             return [];
         const method = propertyName(prop);
-        return method !== undefined && methods.has(method) ? [{ name: prop.value.name, method, step }] : [];
+        return method !== undefined && methods.has(method)
+            ? [{ name: prop.value.name, binding: prop.value, method, step }]
+            : [];
     });
 }
 function memberName(node) {
@@ -389,8 +399,15 @@ function isLocalVariable(sourceCode, id) {
     }
     return false;
 }
+/** Values a constant can hold a test function in: `it.skip`, `it.skipIf(...)`, `` it.each`...` `` or `a ? b : c`. */
+const ALIAS_VALUES = new Set([
+    'MemberExpression',
+    'CallExpression',
+    'TaggedTemplateExpression',
+    'ConditionalExpression',
+]);
 const STATEMENT_CONTAINERS = new Set(['Program', 'BlockStatement', 'StaticBlock', 'SwitchCase', 'TSModuleBlock']);
-/** The statement a call belongs to; its marker block sits above that statement. */
+/** The statement a call, or a value, belongs to; its marker block sits above that statement. */
 /**
  * The declaration a call makes through `Function.prototype.call`, `apply` or `bind`, read as if it were
  * written plainly: `it.skip.call(null, 'title', fn)`, `it.skip.apply(null, ['title', fn])` and
@@ -516,20 +533,21 @@ export function commentLines(comment) {
 }
 function parseMarkers(comment, states) {
     const markers = [];
-    for (const { text, start } of commentLines(comment)) {
+    for (const [line, { text, start }] of commentLines(comment).entries()) {
         const match = MARKER_LINE_RE.exec(text);
         if (!match)
             continue;
         const [, keyword, rest] = match;
         const restOffset = start + match[0].length - rest.length;
+        const at = { comment, keyword, line, keywordStart: start + text.indexOf(keyword) };
         const state = states.find((s) => s.marker === keyword);
         if (state) {
-            markers.push({ comment, keyword, state, ...parseTickets(rest, restOffset, state.ticket) });
+            markers.push({ ...at, state, ...parseTickets(rest, restOffset, state.ticket) });
             continue;
         }
         const caseOf = states.find((s) => s.marker === keyword.toUpperCase());
         if (caseOf)
-            markers.push({ comment, keyword, caseOf, ...parseTickets(rest, restOffset, caseOf.ticket) });
+            markers.push({ ...at, caseOf, ...parseTickets(rest, restOffset, caseOf.ticket) });
     }
     return markers;
 }
@@ -614,10 +632,12 @@ function constantValue(sourceCode, node) {
         return propertyValue(owner, key);
     if (owner.type === 'ArrayExpression') {
         const index = Number(key);
-        if (!Number.isInteger(index))
+        if (!Number.isInteger(index) || index < 0 || String(index) !== key)
+            return undefined;
+        if (owner.elements.slice(0, index + 1).some((element) => element?.type === 'SpreadElement'))
             return undefined;
-        const element = owner.elements[index];
-        return element !== null && element.type !== 'SpreadElement' ? element : undefined;
+        const element = owner.elements.at(index);
+        return element !== undefined && element !== null && element.type !== 'SpreadElement' ? element : undefined;
     }
     if (owner.type !== 'TSEnumDeclaration')
         return undefined;
@@ -684,20 +704,35 @@ function detailKey(sourceCode, prop, unread) {
  * The plain-keyed properties of a details object, following spread objects declared in this file and
  * collecting the ones that can't be read.
  */
-function objectDetails(sourceCode, object, unread) {
-    return object.properties.flatMap((prop) => {
+function objectDetails(sourceCode, object, unread, path = []) {
+    if (path.includes(object)) {
+        unread.push(object);
+        return [];
+    }
+    const entries = new Map();
+    for (const prop of object.properties) {
         if (prop.type === 'SpreadElement') {
             const argument = unwrap(prop.argument);
             const value = argument.type === 'ObjectExpression' ? argument : constantValue(sourceCode, argument);
             const spread = value && unwrap(value);
-            if (spread?.type === 'ObjectExpression')
-                return objectDetails(sourceCode, spread, unread);
-            unread.push(prop.argument);
-            return [];
+            const before = unread.length;
+            const values = spread?.type === 'ObjectExpression' ? objectDetails(sourceCode, spread, unread, [...path, object]) : [];
+            if (spread?.type !== 'ObjectExpression')
+                unread.push(prop.argument);
+            // An unread spread may replace any earlier property; later known properties still win.
+            if (unread.length > before)
+                entries.clear();
+            for (const [key, value] of values)
+                entries.set(key, value);
+            continue;
         }
         const key = detailKey(sourceCode, prop, unread);
-        return key === undefined ? [] : [[key, prop.value]];
-    });
+        if (key === undefined)
+            entries.clear();
+        else
+            entries.set(key, prop.value);
+    }
+    return [...entries];
 }
 /**
  * The details or options object of a declaration, the second argument in
@@ -789,7 +824,7 @@ function collectAnnotations(sourceCode, details, source, annotations) {
         }
         tickets.push({ text, node: description[1] });
     };
-    const readValue = (value) => {
+    const readValue = (value, path = []) => {
         const carrier = annotationCarrier(sourceCode, value);
         if (carrier === 'unread') {
             unread.push(value);
@@ -797,6 +832,10 @@ function collectAnnotations(sourceCode, details, source, annotations) {
         }
         if (carrier === undefined)
             return;
+        if (path.includes(carrier)) {
+            unread.push(value);
+            return;
+        }
         if (source.shape === 'meta') {
             if (carrier.type === 'ObjectExpression') {
                 const unreadKeys = [];
@@ -818,8 +857,12 @@ function collectAnnotations(sourceCode, details, source, annotations) {
             readPlaywright(carrier);
         else {
             for (const element of carrier.elements) {
-                if (element === null || element.type === 'SpreadElement')
+                if (element === null)
+                    continue;
+                if (element.type === 'SpreadElement') {
+                    readValue(element.argument, [...path, carrier]);
                     continue;
+                }
                 const inner = annotationCarrier(sourceCode, element);
                 if (inner === 'unread')
                     unread.push(element);
@@ -983,9 +1026,13 @@ const OPTION_VALUES = new Set([
  * Whether a runtime call always applies: it has no condition, or `true`, or with `notes` only a note, as
  * Vitest's `context.skip('Broker sandbox is down')`, and nothing around it makes it conditional.
  */
-function isUnconditional(call, notes) {
+function isUnconditional(call, framework) {
     const first = call.arguments.at(0);
-    const always = first === undefined || booleanOf(first) === true || (notes && isStaticText(first));
+    const always = first === undefined ||
+        booleanOf(first) === true ||
+        // node:test's `t.skip(message)` and Jasmine's `pending(message)` take no condition, so any argument is a note.
+        framework.reasonArgument === 'only' ||
+        (framework.skipNotes && isStaticText(first));
     return always && !isGuarded(call);
 }
 /**
@@ -1006,9 +1053,13 @@ function saysWhy(sourceCode, node) {
     const value = unwrap(node);
     return value.type !== 'Literal' && !(value.type === 'Identifier' && value.name === 'undefined');
 }
-/** Whether `node` is text that isn't blank. */
+/**
+ * Whether `node` is text that isn't blank, or a template with values in it, as `` `${browserName} has no
+ * clipboard` ``, which is taken on trust.
+ */
 function isReasonText(sourceCode, node) {
-    return Boolean(staticText(sourceCode, node)?.trim());
+    const text = staticText(sourceCode, node);
+    return text === undefined ? unwrap(node).type === 'TemplateLiteral' : text.trim() !== '';
 }
 /** Whether a runtime call gives the reason for its state where its framework takes one (see `reasonArgument`). */
 function callReason(sourceCode, call, where) {
@@ -1017,7 +1068,8 @@ function callReason(sourceCode, call, where) {
     if (where === 'only')
         return first !== undefined && saysWhy(sourceCode, first);
     // Vitest's `context.skip(isMobile)` takes a condition, so only text first is a reason.
-    if (where === 'either' && first !== undefined && staticText(sourceCode, first) !== undefined) {
+    const text = first !== undefined && (staticText(sourceCode, first) !== undefined || unwrap(first).type === 'TemplateLiteral');
+    if (where === 'either' && text) {
         return isReasonText(sourceCode, first);
     }
     return second !== undefined && saysWhy(sourceCode, second);
@@ -1109,7 +1161,7 @@ function runAnalysis(sourceCode, options) {
      * `['describe', 'skip']` for `test.describe.skip` or `pw.test.describe.skip`. Undefined when the callee
      * isn't one of the framework's test functions.
      */
-    const target = (chain) => {
+    const target = (chain, seen = []) => {
         if (chain === undefined)
             return undefined;
         const { root, path, args } = chain;
@@ -1131,7 +1183,13 @@ function runAnalysis(sourceCode, options) {
             base = member;
             rest = path.slice(1);
         }
-        return base !== undefined && !isLocalVariable(sourceCode, root) ? { root: base, path: rest, args } : undefined;
+        if (base !== undefined && !isLocalVariable(sourceCode, root))
+            return { root: base, path: rest, args };
+        const value = declaredValue(sourceCode, root);
+        if (value === undefined || seen.includes(value))
+            return undefined;
+        const alias = target(chainOf(unwrap(value), framework.factories), [...seen, value]);
+        return alias && { root: alias.root, path: [...alias.path, ...path], args: new Map([...alias.args, ...args]) };
     };
     let usesTest = sourceCode.ast.body.some((statement) => statement.type === 'ImportDeclaration' && framework.ownsModule(statement.source.value));
     const subjects = [];
@@ -1140,9 +1198,11 @@ function runAnalysis(sourceCode, options) {
     const commentedOut = findCommentedOutTests(sourceCode, allComments, new Set([
         ...options.testFunctions,
         ...[...framework.exports, ...framework.globals].flatMap(([name, root]) => (root.kind === 'hook' ? [] : [name])),
-    ]), states);
+    ]), new Set([...framework.testMembers, ...framework.describeMembers, 'describe', 'step'].map((m) => m.replace('()', ''))), states);
     const comments = allComments.filter((comment) => !commentedOut.comments.has(comment));
     const regions = disableRegions(comments, states);
+    // A region's marker covers every test up to its `eslint-enable`, so it is never the own marker of the first.
+    const regionComments = new Set(regions.map((r) => r.comment));
     // `test.skip(...); // eslint-disable-line rule -- SKIP: TRADE-1` holds its marker on the test's own line.
     const lineDirectives = new Map();
     for (const comment of comments) {
@@ -1152,6 +1212,13 @@ function runAnalysis(sourceCode, options) {
     }
     const stack = [];
     const infos = [];
+    const infoOf = (id) => {
+        const info = infos.findLast((entry) => entry.name === id.name);
+        return info?.binding !== undefined &&
+            declaredVariable(sourceCode, id) !== declaredVariable(sourceCode, info.binding)
+            ? undefined
+            : info;
+    };
     const keys = sourceCode.visitorKeys;
     /** States an options object can put a test in, such as `skip` for Vitest's `{ skip: true }`. */
     const optionModifiers = new Set(framework.optionEffects.values());
@@ -1162,12 +1229,12 @@ function runAnalysis(sourceCode, options) {
     /** Describe bodies written as a `function`, whose `this` is Mocha's suite, which `this.retries()` acts on. */
     const suiteBodies = new Set();
     /**
-     * Whether a statement around `anchor` has a comment that says something above it, as `// why` above an `if`,
-     * up to `owner`, the test or describe the call acts on. The walk goes on through a callback passed to another
+     * Whether `anchor` or a statement around it has a comment that says something above it or at the end of its
+     * first line, as `// why` above an `if` or after its `{`, up to `owner`, the test or describe the call acts on. The walk goes on through a callback passed to another
      * call, such as a hook's or a step's, but stops at a function declared some other way.
      */
     const commentedAround = (anchor, owner) => {
-        for (let node = anchor.parent; node; node = node.parent) {
+        for (let node = anchor; node; node = node.parent) {
             if (FUNCTIONS.has(node.type)) {
                 const call = node.parent;
                 if (call?.type !== 'CallExpression' || call === owner || !call.arguments.includes(node)) {
@@ -1179,7 +1246,11 @@ function runAnalysis(sourceCode, options) {
             if (!container || !STATEMENT_CONTAINERS.has(container.type))
                 continue;
             const block = commentBlock(sourceCode, node, options.allowBlankLine);
-            if (block.some((comment) => !commentedOut.comments.has(comment) && hasText(comment)))
+            if (block.some((c) => !commentedOut.comments.has(c) && !regionComments.has(c) && hasText(c)))
+                return true;
+            // `if (isMobile) { // why`: a comment at the end of the line the statement starts on.
+            const first = sourceCode.getCommentsInside(node).at(0);
+            if (first?.loc.start.line === node.loc.start.line && hasText(first))
                 return true;
         }
         return false;
@@ -1200,17 +1271,18 @@ function runAnalysis(sourceCode, options) {
             block.push(...commentBlock(sourceCode, call, options.allowBlankLine).filter((c) => !commentedOut.comments.has(c)));
         }
         block.push(...(lineDirectives.get(call.loc.start.line) ?? []));
-        const inRegions = regions.filter((r) => r.start <= call.range[0] && call.range[0] < r.end && !block.includes(r.comment));
+        const inRegions = regions.filter((r) => r.start <= call.range[0] && call.range[0] < r.end);
         for (const comment of [...block, ...inRegions.map((r) => r.comment)])
             claimed.add(comment);
-        const commented = [...block, ...inRegions.map((r) => r.comment)].some(hasText);
-        // A runtime call can also say why above the statements around it in its function, above its test, or in
-        // its arguments.
-        const reasonedCall = () => kind === 'runtime' &&
-            ((framework.reasonArgument !== undefined && callReason(sourceCode, call, framework.reasonArgument)) ||
-                parent?.commented === true ||
-                trailingText(anchor) ||
-                commentedAround(anchor, parent?.node));
+        // A region's description says why a rule is off, not why a test is skipped; its marker's ticket counts.
+        const commented = block.some((comment) => !regionComments.has(comment) && hasText(comment));
+        // A comment at the end of the line also says why. A runtime call can also say why above the statements
+        // around it in its function, above its test, or in its arguments.
+        const reasonedCall = () => trailingText(anchor) ||
+            (kind === 'runtime' &&
+                ((framework.reasonArgument !== undefined && callReason(sourceCode, call, framework.reasonArgument)) ||
+                    parent?.commented === true ||
+                    commentedAround(anchor, parent?.node)));
         const ownTags = new Set(tagInfo.tags.map((t) => t.tag));
         const sources = [];
         for (const state of states) {
@@ -1252,7 +1324,7 @@ function runAnalysis(sourceCode, options) {
             for (const tag of parent.tags)
                 inheritedTags.add(tag.tag);
         }
-        const ownSkip = [...modifiers].some(([modifier, always]) => always && SKIPPING_MODIFIERS.has(modifier));
+        const ownSkip = [...modifiers].some(([modifier, always]) => always && SKIPPING_MODIFIERS.has(modifier) && !(modifier === 'todo' && framework.name === 'node-test'));
         const subject = {
             kind,
             node: call,
@@ -1266,9 +1338,10 @@ function runAnalysis(sourceCode, options) {
             inheritedTags,
             unreadTags: tagInfo.unread,
             unknownStates,
+            sharedStates: new Set(),
             skipped: ownSkip || (kind !== 'runtime' && parent?.skipped === true),
             ownSkip,
-            markers: block.flatMap((comment) => parseMarkers(comment, states)),
+            markers: block.flatMap((comment) => (regionComments.has(comment) ? [] : parseMarkers(comment, states))),
             regionMarkers: inRegions.flatMap((r) => r.markers),
             annotationTickets: tagInfo.annotations,
             unreadTickets: tagInfo.unreadAnnotations,
@@ -1386,8 +1459,8 @@ function runAnalysis(sourceCode, options) {
      * `(isCI ? describe.skip : describe)('order entry', ...)`: a test or describe whose function is picked by
      * a condition. A state that only one side has depends on the condition, like `test.skip(isCI)`.
      */
-    const pickedDeclaration = (call) => {
-        const callee = unwrap(call.callee);
+    const pickedDeclaration = (call, picker) => {
+        const callee = unwrap(picker);
         if (callee.type !== 'ConditionalExpression')
             return undefined;
         const [yes, no] = [callee.consequent, callee.alternate].map((side) => {
@@ -1449,29 +1522,67 @@ function runAnalysis(sourceCode, options) {
         if (!framework.subtests || callee.type !== 'MemberExpression' || memberName(callee) !== 'test')
             return undefined;
         const { object } = callee;
-        if (object.type !== 'Identifier' || !infos.findLast((info) => info.name === object.name)?.methods)
+        if (object.type !== 'Identifier' || !infoOf(object)?.methods)
             return undefined;
         const declaration = { kind: 'test', members: [], written: [], args: new Map() };
         return declares(declaration, call.arguments)
             ? declare(call, declaration, bodyInfos(call.arguments, []))
             : undefined;
     };
+    /**
+     * The value of a constant that holds a test function the collected names can't: one a condition picks, as
+     * `const itIf = isCI ? it.skip : it`, one a factory builds, as `const d = describe.runIf(hasDocker)`, or any
+     * declared inside a function.
+     */
+    const aliasValue = (callee) => {
+        if (callee.type !== 'Identifier' || testNames.roots.has(callee.name))
+            return undefined;
+        const seen = new Set();
+        let value = declaredValue(sourceCode, callee);
+        while (value !== undefined && !seen.has(value)) {
+            seen.add(value);
+            const expression = unwrap(value);
+            if (expression.type !== 'Identifier')
+                return ALIAS_VALUES.has(expression.type) ? value : undefined;
+            value = declaredValue(sourceCode, expression);
+        }
+        return undefined;
+    };
+    /**
+     * Whether the declaration of a constant that holds a test function says why above it or at the end of its
+     * line, as `// no symlinks on Windows` above `const posixTest = isWindows ? test.skip : test`.
+     */
+    const aliasCommented = (value) => {
+        const statement = anchorOf(value);
+        const block = commentBlock(sourceCode, statement, options.allowBlankLine);
+        return (block.some((c) => !commentedOut.comments.has(c) && !regionComments.has(c) && hasText(c)) ||
+            trailingText(statement));
+    };
     const visitCall = (original) => {
+        const alias = aliasValue(throughFunctionMethods(original).callee);
+        const visited = visitDeclaredCall(original, alias);
+        if (alias && visited.subject && aliasCommented(alias)) {
+            for (const source of visited.subject.states)
+                if (source.reasoned === false)
+                    source.reasoned = true;
+        }
+        return visited;
+    };
+    const visitDeclaredCall = (original, alias) => {
         const call = throughFunctionMethods(original);
-        const callee = target(chainOf(call.callee, framework.factories));
+        const written = alias ?? call.callee;
+        const callee = target(chainOf(written, framework.factories));
         if (callee === undefined) {
-            return subtestOf(call) ?? pickedDeclaration(call) ?? { subject: runtimeCall(call) ?? retryCall(call) };
+            return subtestOf(call) ?? pickedDeclaration(call, written) ?? { subject: runtimeCall(call) ?? retryCall(call) };
         }
         usesTest = true;
         const args = call.arguments;
         const { path } = callee;
-        if (framework.retryCall === 'describe.configure' && path.join('.') === 'describe.configure') {
-            const options = args.at(0);
-            const object = options && unwrap(options);
-            const count = object?.type === 'ObjectExpression'
-                ? object.properties.find((p) => p.type === 'Property' && propertyName(p) === 'retries')
-                : undefined;
-            return { subject: retrySubject(call, count?.type === 'Property' ? count.value : undefined, 'configure') };
+        // `test.describe.configure(...)`, or `describe.configure(...)` with `const { describe } = test`.
+        const configure = path.join('.') === 'describe.configure' || (callee.root === DESCRIBE && path.join('.') === 'configure');
+        if (framework.retryCall === 'describe.configure' && configure) {
+            const count = detailsOf(sourceCode, call, true).entries.findLast(([key]) => key === 'retries');
+            return { subject: retrySubject(call, count?.[1], 'configure') };
         }
         const declaration = declarationOf(callee);
         // Vitest's `beforeEach((context) => context.skip())` and Mocha's `before(function () { this.skip(); })`
@@ -1510,14 +1621,12 @@ function runAnalysis(sourceCode, options) {
      */
     const runtimeCall = (call) => {
         const { callee } = call;
-        // The innermost parameter with a name is the one the call uses.
-        const innermost = (name) => infos.findLast((info) => info.name === name);
         /**
          * What a name stands for: a context in scope, or a local constant that keeps one of its methods, as
          * `const skip = testInfo.skip`, `const { skip } = t` or `const p = pending`.
          */
         const resolveInfo = (id) => {
-            const direct = innermost(id.name);
+            const direct = infoOf(id);
             if (direct !== undefined)
                 return direct;
             const definition = declaredVariable(sourceCode, id)?.defs.find((def) => def.type === 'Variable');
@@ -1536,12 +1645,12 @@ function runAnalysis(sourceCode, options) {
                             ? { name: id.name, method: name }
                             : undefined;
                     }
-                    const object = init.object.type === 'Identifier' ? innermost(init.object.name) : undefined;
+                    const object = init.object.type === 'Identifier' ? infoOf(init.object) : undefined;
                     return object?.methods?.has(name) ? { name: id.name, method: name, step: object.step } : undefined;
                 }
                 if (init.type !== 'Identifier')
                     return undefined;
-                const source = innermost(init.name);
+                const source = infoOf(init);
                 if (source === undefined)
                     return undefined;
                 const fn = source.runtimeFunction;
@@ -1553,7 +1662,7 @@ function runAnalysis(sourceCode, options) {
             }
             if (declarator.id.type !== 'ObjectPattern' || init.type !== 'Identifier')
                 return undefined;
-            const source = innermost(init.name);
+            const source = infoOf(init);
             if (source?.methods === undefined)
                 return undefined;
             const property = declarator.id.properties.find((prop) => prop.type === 'Property' && prop.value.type === 'Identifier' && prop.value.name === id.name);
@@ -1635,9 +1744,11 @@ function runAnalysis(sourceCode, options) {
         return subject;
     };
     /** `step` is set for `step.skip()`, which skips only its step; the other calls act on the whole test. */
-    const runtimeSubject = (call, modifier, step, always = isUnconditional(call, framework.skipNotes)) => {
+    const runtimeSubject = (call, modifier, step, always = isUnconditional(call, framework)) => {
         if (!states.some((s) => s.modifier === modifier))
             return undefined;
+        if (framework.reasonArgument !== 'only' && booleanOf(call.arguments.at(0)) === false)
+            return undefined;
         const subject = makeSubject('runtime', call, new Map([[modifier, always]]), NO_TAGS, step ?? stack.findLast((s) => s.kind !== 'step'));
         const parent = subject.parent;
         if (parent) {
@@ -1676,7 +1787,36 @@ function runAnalysis(sourceCode, options) {
         .filter((comment) => !claimed.has(comment))
         .flatMap((comment) => parseMarkers(comment, states))
         .filter(isStateMarker);
-    return { subjects, detachedMarkers, commentedOutTests: commentedOut.found, isTestFile: usesTest };
+    const byAnchor = new Map();
+    for (const subject of subjects)
+        byAnchor.set(subject.anchor, [...(byAnchor.get(subject.anchor) ?? []), subject]);
+    for (const subject of subjects) {
+        // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- every subject's anchor is a key
+        for (const other of byAnchor.get(subject.anchor)) {
+            if (other === subject)
+                continue;
+            for (const marker of subject.markers) {
+                if (marker.state && appliesTo(other, marker.state.name))
+                    subject.sharedStates.add(marker.state.name);
+            }
+        }
+    }
+    const idleRegionMarkers = regions
+        .flatMap((region) => region.markers)
+        .filter(isStateMarker)
+        .filter((marker) => {
+        const covered = subjects.filter((subject) => subject.regionMarkers.includes(marker));
+        return (covered.length > 0 &&
+            !isWorkComment(marker, options) &&
+            !covered.some((s) => appliesTo(s, marker.state.name) || s.unknownStates.has(marker.state.name)));
+    });
+    return {
+        subjects,
+        detachedMarkers,
+        idleRegionMarkers,
+        commentedOutTests: commentedOut.found,
+        isTestFile: usesTest,
+    };
 }
 /** Whether `subject` is in `stateName` at all, required or not, including inherited and runtime states. */
 export function appliesTo(subject, stateName) {
@@ -1701,7 +1841,7 @@ function candidateMarkers(subject, state) {
 export function evaluate(subject, state) {
     const markers = candidateMarkers(subject, state);
     if (markers.length === 0) {
-        const marker = subject.markers.find((m) => m.caseOf === state);
+        const marker = [...subject.markers, ...subject.regionMarkers].find((m) => m.caseOf === state);
         return marker ? { kind: 'case', marker } : { kind: 'missing' };
     }
     const isValid = (m) => m.tickets.length > 0 && m.tickets.every((t) => t.result === 'ok');
@@ -1775,8 +1915,12 @@ function isWorkComment(marker, options) {
 export function strayMarkers(subject, options) {
     return subject.markers.flatMap((marker) => {
         const state = marker.state ?? (marker.tickets.at(0)?.result === 'ok' ? marker.caseOf : undefined);
-        if (state === undefined || appliesTo(subject, state.name) || subject.unknownStates.has(state.name))
+        if (state === undefined ||
+            appliesTo(subject, state.name) ||
+            subject.unknownStates.has(state.name) ||
+            subject.sharedStates.has(state.name)) {
             return [];
+        }
         return isWorkComment(marker, options) ? [] : [{ ...marker, state }];
     });
 }

package/dist/utils/create-rule.js

@@ -7,7 +7,6 @@ import { resolveOptions } from "./options.js";
 export function createRule(definition) {
     return {
         meta: definition.meta,
-        defaultOptions: [],
         create(context) {
             const options = resolveOptions(context.settings);
             return {

package/dist/utils/fix.d.ts

@@ -1,13 +1,16 @@
 import type { TSESLint, TSESTree } from '@typescript-eslint/utils';
 import { type Marker } from './analyze.ts';
 type SourceCode = Readonly<TSESLint.SourceCode>;
-/** Range of `keyword` where it is used as a marker (`KEYWORD:`) inside `comment`. */
-export declare function keywordRange(sourceCode: SourceCode, comment: TSESTree.Comment, keyword: string): TSESTree.Range;
+/** Range of a marker's keyword on the marker's own line. */
+export declare function keywordRange(marker: Marker): TSESTree.Range;
 /**
- * Removes a marker comment, and its whole line when nothing else is on it. From an ESLint directive it
- * removes only the description, so the directive keeps working.
+ * Removes a marker. From a comment that says more, it removes only the marker's line. Otherwise it removes
+ * the comment, and its whole line when nothing else is on it, or from an ESLint directive only the
+ * description, so the directive keeps working.
  */
-export declare function removeMarkerComment(sourceCode: SourceCode, comment: TSESTree.Comment): TSESLint.RuleFix;
+export declare function removeMarkerComment(sourceCode: SourceCode, marker: Marker): TSESLint.RuleFix;
+/** The line break that ends the line `comment` ends on. */
+export declare function lineBreakAfter(sourceCode: SourceCode, comment: TSESTree.Comment): string;
 /** Indentation of the line `comment` starts on. */
 export declare function indentOf(sourceCode: SourceCode, comment: TSESTree.Comment): string;
 /**