Various tweaks

Author: sindresorhus

create-ava-rule.js

@@ -1,25 +1,129 @@
+/* eslint-disable eslint-plugin/prefer-message-ids, eslint-plugin/prefer-object-rule, eslint-plugin/require-meta-docs-description, eslint-plugin/require-meta-docs-recommended, eslint-plugin/require-meta-schema, eslint-plugin/require-meta-type */
 import enhance from 'enhance-visitors';
-import {getTestModifiers, unwrapTypeExpression} from './util.js';
+import {findVariable} from '@eslint-community/eslint-utils';
+import {hasComputedTestModifier, unwrapTypeExpression} from './util.js';
 
-export default () => {
+const trackedAliasModifiers = new Set([
+	'after',
+	'afterEach',
+	'always',
+	'before',
+	'beforeEach',
+	'failing',
+	'macro',
+	'only',
+	'serial',
+	'skip',
+	'todo',
+]);
+
+const createAvaRule = sourceCode => {
 	let isTestFile = false;
 	let currentTestNode;
-	const testIdentifiers = new Set();
+	const testBindings = new WeakMap();
+	// Cache per-reference resolution so repeated helper calls on the same node stay cheap.
+	const trackedModifiersCache = new WeakMap();
+	const testFunctionCallCache = new WeakMap();
+	const testModifierNamesCache = new WeakMap();
+
+	function getTrackedModifiersFromVariable(variable, node) {
+		const currentReference = variable.references.find(reference => reference.identifier === node);
+		const currentVariableScope = currentReference?.from.variableScope;
+		const isReassignedBeforeUse = variable.references.some(reference => reference.isWrite()
+			&& !reference.init
+			&& reference.identifier.range[0] < node.range[0]
+			&& reference.from.variableScope === currentVariableScope);
+		if (isReassignedBeforeUse) {
+			return undefined;
+		}
+
+		for (const definition of variable.defs) {
+			const modifiers = testBindings.get(definition.name);
+			if (modifiers !== undefined) {
+				return modifiers;
+			}
+		}
+	}
+
+	function getTrackedModifiers(node) {
+		if (node.type !== 'Identifier') {
+			return undefined;
+		}
+
+		if (trackedModifiersCache.has(node)) {
+			return trackedModifiersCache.get(node);
+		}
+
+		const variable = findVariable(sourceCode.getScope(node), node);
+		const modifiers = variable
+			? getTrackedModifiersFromVariable(variable, node)
+			: testBindings.get(node);
+		trackedModifiersCache.set(node, modifiers);
+		return modifiers;
+	}
+
+	function trackTestBinding(binding, modifiers = []) {
+		// Bindings, not names, preserve alias semantics without leaking across shadowed scopes.
+		testBindings.set(binding, modifiers);
+	}
 
 	function isTestFunctionCall(node) {
-		if (node.type === 'Identifier') {
-			return testIdentifiers.has(node.name);
+		if (testFunctionCallCache.has(node)) {
+			return testFunctionCallCache.get(node);
 		}
 
-		if (node.type === 'MemberExpression') {
-			return isTestFunctionCall(node.object);
+		let isTestFunction = false;
+
+		switch (node.type) {
+			case 'Identifier': {
+				isTestFunction = getTrackedModifiers(node) !== undefined;
+				break;
+			}
+
+			case 'MemberExpression': {
+				isTestFunction = isTestFunctionCall(unwrapTypeExpression(node.object));
+				break;
+			}
+
+			default: {
+				break;
+			}
 		}
 
-		return false;
+		testFunctionCallCache.set(node, isTestFunction);
+		return isTestFunction;
 	}
 
 	function getTestModifierNames(node) {
-		return getTestModifiers(node).map(property => property.name);
+		if (testModifierNamesCache.has(node)) {
+			return testModifierNamesCache.get(node);
+		}
+
+		let modifierNames = [];
+
+		switch (node.type) {
+			case 'CallExpression': {
+				modifierNames = getTestModifierNames(node.callee);
+				break;
+			}
+
+			case 'Identifier': {
+				modifierNames = getTrackedModifiers(node) ?? [];
+				break;
+			}
+
+			case 'MemberExpression': {
+				modifierNames = [...getTestModifierNames(unwrapTypeExpression(node.object)), node.property.name];
+				break;
+			}
+
+			default: {
+				break;
+			}
+		}
+
+		testModifierNamesCache.set(node, modifierNames);
+		return modifierNames;
 	}
 
 	/* eslint quote-props: [2, "as-needed"] */
@@ -36,19 +140,28 @@ export default () => {
 
 				if (specifier.type === 'ImportDefaultSpecifier') {
 					isTestFile = true;
-					testIdentifiers.add(specifier.local.name);
+					trackTestBinding(specifier.local);
 				} else if (specifier.type === 'ImportSpecifier' && specifier.imported.name === 'serial') {
 					isTestFile = true;
-					testIdentifiers.add(specifier.local.name);
+					trackTestBinding(specifier.local, ['serial']);
 				}
 			}
 		},
 		VariableDeclarator(node) {
 			const init = unwrapTypeExpression(node.init);
 
-			// Track re-assignment from a test identifier (e.g., `const test = anyTest as TestFn<Context>`)
-			if (init?.type === 'Identifier' && testIdentifiers.has(init.name) && node.id.type === 'Identifier') {
-				testIdentifiers.add(node.id.name);
+			// Track aliases of test identifiers:
+			// - Re-assignment: `const test = anyTest as TestFn<Context>`
+			// - Member access: `const serial = test.serial`
+			// Mutable aliases are allowed, but later writes stop them from being treated as AVA bindings.
+			if (
+				init
+				&& node.id.type === 'Identifier'
+				&& isTestFunctionCall(init)
+				&& !hasComputedTestModifier(init)
+				&& getTestModifierNames(init).every(modifier => trackedAliasModifiers.has(modifier))
+			) {
+				trackTestBinding(node.id, getTestModifierNames(init));
 			}
 		},
 		CallExpression(node) {
@@ -65,7 +178,6 @@ export default () => {
 		},
 		'Program:exit'() {
 			isTestFile = false;
-			testIdentifiers.clear();
 		},
 	};
 
@@ -85,3 +197,5 @@ export default () => {
 		merge: customHandlers => enhance.mergeVisitors([predefinedRules, customHandlers]),
 	};
 };
+
+export default createAvaRule;

rules/assertion-arguments.js

@@ -227,7 +227,7 @@ function isString(node) {
 }
 
 const create = context => {
-	const ava = createAvaRule();
+	const ava = createAvaRule(context.sourceCode);
 	const options = context.options[0];
 	const enforcesMessage = Boolean(options.message);
 	const shouldHaveMessage = options.message !== 'never';
@@ -346,6 +346,8 @@ const create = context => {
 					} else if (!/^(?:[A-Z][a-z\d]*)*Error$/.test(lastArgument.name)) {
 						return;
 					}
+				} else if (lastArgument.type === 'MemberExpression' || lastArgument.type === 'ChainExpression' || lastArgument.type === 'CallExpression') {
+					return; // Cannot statically determine the type (e.g. `error.message`, `getMessage()`)
 				}
 
 				if (!isString(lastArgument)) {

rules/failing-test-url.js

@@ -7,7 +7,7 @@ const MESSAGE_ID = 'failing-test-url';
 const urlPattern = /https?:\/\/\S+/;
 
 const create = context => {
-	const ava = createAvaRule();
+	const ava = createAvaRule(context.sourceCode);
 
 	return ava.merge({
 		CallExpression: visitIf([

rules/hooks-order.js

@@ -27,7 +27,7 @@ const buildMessage = (name, orders, visited) => {
 };
 
 const create = context => {
-	const ava = createAvaRule();
+	const ava = createAvaRule(context.sourceCode);
 
 	const orders = buildOrders([
 		'before',
@@ -52,6 +52,10 @@ const create = context => {
 				return;
 			}
 
+			if (ava.hasTestModifier('macro')) {
+				return;
+			}
+
 			const name = util.getHookName(node) ?? 'test';
 
 			visited[name] = node;

rules/max-asserts.js

@@ -7,7 +7,7 @@ const MESSAGE_ID = 'max-asserts';
 const notAssertionMethods = new Set(['plan', 'end']);
 
 const create = context => {
-	const ava = createAvaRule();
+	const ava = createAvaRule(context.sourceCode);
 	const {max: maxAssertions} = context.options[0];
 	let assertionCount = 0;
 	let nodeToReport;

rules/no-async-fn-without-await.js

@@ -6,7 +6,8 @@ const MESSAGE_ID = 'no-async-fn-without-await';
 const MESSAGE_ID_SUGGESTION = 'no-async-fn-without-await-suggestion';
 
 const create = context => {
-	const ava = createAvaRule();
+	const ava = createAvaRule(context.sourceCode);
+	const {sourceCode} = context;
 	let testUsed = false;
 	let asyncTest;
 	let nestedFunctionDepth = 0;
@@ -36,8 +37,8 @@ const create = context => {
 			ava.isInTestFile,
 			ava.isTestNode,
 		])(node => {
-			asyncTest = (isAsync(node.arguments[0]) && node.arguments[0])
-				|| (isAsync(node.arguments[1]) && node.arguments[1]);
+			const implementationArgument = util.getExecutableTestImplementation(node, sourceCode);
+			asyncTest = isAsync(implementationArgument) && implementationArgument;
 		}),
 		':function': enterFunction,
 		':function:exit': exitFunction,

rules/no-commented-tests.js

@@ -6,7 +6,7 @@ const MESSAGE_ID = 'no-commented-tests';
 const commentedTestPattern = /^\s*\*?\s*(?:test|serial)\s*(?:\.\s*\w+\s*)*\(/;
 
 const create = context => {
-	const ava = createAvaRule();
+	const ava = createAvaRule(context.sourceCode);
 
 	return ava.merge({
 		'Program:exit'() {

rules/no-conditional-assertion.js

@@ -269,7 +269,7 @@ function shouldTrackConditionalAncestor(node, child) {
 }
 
 const create = context => {
-	const ava = createAvaRule();
+	const ava = createAvaRule(context.sourceCode);
 
 	return ava.merge({
 		CallExpression: visitIf([ava.isInTestFile, ava.isInTestNode])(node => {

rules/no-duplicate-hooks.js

@@ -5,7 +5,7 @@ import util from '../util.js';
 const MESSAGE_ID = 'no-duplicate-hooks';
 
 const create = context => {
-	const ava = createAvaRule();
+	const ava = createAvaRule(context.sourceCode);
 	const seen = new Set();
 
 	return ava.merge({

rules/no-duplicate-modifiers.js

@@ -7,7 +7,7 @@ const MESSAGE_ID = 'no-duplicate-modifiers';
 const sortByName = (a, b) => a.name.localeCompare(b.name);
 
 const create = context => {
-	const ava = createAvaRule();
+	const ava = createAvaRule(context.sourceCode);
 
 	return ava.merge({
 		CallExpression: visitIf([