Use simple selectors (#2134)

Author: fisker

rules/ast/function-types.js

@@ -0,0 +1,5 @@
+'use strict';
+
+const functionTypes = ['FunctionDeclaration', 'FunctionExpression', 'ArrowFunctionExpression'];
+
+module.exports = functionTypes;

rules/ast/index.js

@@ -33,4 +33,6 @@ module.exports = {
 	isReferenceIdentifier: require('./is-reference-identifier.js'),
 	isStaticRequire: require('./is-static-require.js'),
 	isUndefined: require('./is-undefined.js'),
+
+	functionTypes: require('./function-types.js'),
 };

rules/ast/is-function.js

@@ -1,9 +1,8 @@
 'use strict';
+const functionTypes = require('./function-types.js');
 
 function isFunction(node) {
-	return node.type === 'FunctionDeclaration'
-		|| node.type === 'FunctionExpression'
-		|| node.type === 'ArrowFunctionExpression';
+	return functionTypes.includes(node.type);
 }
 
 module.exports = isFunction;

rules/better-regex.js

@@ -2,7 +2,7 @@
 const cleanRegexp = require('clean-regexp');
 const {optimize} = require('regexp-tree');
 const escapeString = require('./utils/escape-string.js');
-const {isStringLiteral, isNewExpression} = require('./ast/index.js');
+const {isStringLiteral, isNewExpression, isRegexLiteral} = require('./ast/index.js');
 
 const MESSAGE_ID = 'better-regex';
 const MESSAGE_ID_PARSE_ERROR = 'better-regex/parse-error';
@@ -22,7 +22,11 @@ const create = context => {
 	}
 
 	return {
-		'Literal[regex]'(node) {
+		Literal(node) {
+			if (!isRegexLiteral(node)) {
+				return;
+			}
+
 			const {raw: original, regex} = node;
 
 			// Regular Expressions with `u` flag are not well handled by `regexp-tree`

rules/consistent-function-scoping.js

@@ -1,7 +1,12 @@
 'use strict';
 const {getFunctionHeadLocation, getFunctionNameWithKind} = require('@eslint-community/eslint-utils');
-const getReferences = require('./utils/get-references.js');
-const {isNodeMatches} = require('./utils/is-node-matches.js');
+const {
+	getReferences,
+	isNodeMatches,
+} = require('./utils/index.js');
+const {
+	functionTypes,
+} = require('./ast/index.js');
 
 const MESSAGE_ID = 'consistent-function-scoping';
 const messages = {
@@ -154,41 +159,41 @@ const create = context => {
 
 	const functions = [];
 
-	return {
-		':function'() {
-			functions.push(false);
-		},
-		JSXElement() {
-			// Turn off this rule if we see a JSX element because scope
-			// references does not include JSXElement nodes.
-			if (functions.length > 0) {
-				functions[functions.length - 1] = true;
-			}
-		},
-		':function:exit'(node) {
-			const currentFunctionHasJsx = functions.pop();
-			if (currentFunctionHasJsx) {
-				return;
-			}
-
-			if (node.type === 'ArrowFunctionExpression' && !checkArrowFunctions) {
-				return;
-			}
-
-			if (checkNode(node, scopeManager)) {
-				return;
-			}
-
-			return {
-				node,
-				loc: getFunctionHeadLocation(node, sourceCode),
-				messageId: MESSAGE_ID,
-				data: {
-					functionNameWithKind: getFunctionNameWithKind(node, sourceCode),
-				},
-			};
-		},
-	};
+	context.on(functionTypes, () => {
+		functions.push(false);
+	});
+
+	context.on('JSXElement', () => {
+		// Turn off this rule if we see a JSX element because scope
+		// references does not include JSXElement nodes.
+		if (functions.length > 0) {
+			functions[functions.length - 1] = true;
+		}
+	});
+
+	context.onExit(functionTypes, node => {
+		const currentFunctionHasJsx = functions.pop();
+		if (currentFunctionHasJsx) {
+			return;
+		}
+
+		if (node.type === 'ArrowFunctionExpression' && !checkArrowFunctions) {
+			return;
+		}
+
+		if (checkNode(node, scopeManager)) {
+			return;
+		}
+
+		return {
+			node,
+			loc: getFunctionHeadLocation(node, sourceCode),
+			messageId: MESSAGE_ID,
+			data: {
+				functionNameWithKind: getFunctionNameWithKind(node, sourceCode),
+			},
+		};
+	});
 };
 
 const schema = [

rules/custom-error-definition.js

@@ -183,11 +183,23 @@ const customErrorExport = (context, node) => {
 };
 
 /** @param {import('eslint').Rule.RuleContext} context */
-const create = context => ({
-	ClassDeclaration: node => customErrorDefinition(context, node),
-	'AssignmentExpression[right.type="ClassExpression"]': node => customErrorDefinition(context, node.right),
-	'AssignmentExpression[left.type="MemberExpression"][left.object.type="Identifier"][left.object.name="exports"]': node => customErrorExport(context, node),
-});
+const create = context => {
+	context.on('ClassDeclaration', node => customErrorDefinition(context, node));
+	context.on('AssignmentExpression', node => {
+		if (node.right.type === 'ClassExpression') {
+			return customErrorDefinition(context, node.right);
+		}
+	});
+	context.on('AssignmentExpression', node => {
+		if (
+			node.left.type === 'MemberExpression'
+			&& node.left.object.type === 'Identifier'
+			&& node.left.object.name === 'exports'
+		) {
+			return customErrorExport(context, node);
+		}
+	});
+};
 
 /** @type {import('eslint').Rule.RuleModule} */
 module.exports = {

rules/error-message.js

@@ -26,8 +26,8 @@ const builtinErrors = [
 ];
 
 /** @param {import('eslint').Rule.RuleContext} context */
-const create = context => ({
-	'CallExpression,NewExpression'(expression) {
+const create = context => {
+	context.on(['CallExpression', 'NewExpression'], expression => {
 		if (!isCallOrNewExpression(expression, {
 			names: builtinErrors,
 			optional: false,
@@ -88,8 +88,8 @@ const create = context => ({
 				messageId: MESSAGE_ID_EMPTY_MESSAGE,
 			};
 		}
-	},
-});
+	});
+};
 
 /** @type {import('eslint').Rule.RuleModule} */
 module.exports = {

rules/escape-case.js

@@ -22,31 +22,32 @@ const getProblem = ({node, original, regex = escapeWithLowercase, fix}) => {
 };
 
 /** @param {import('eslint').Rule.RuleContext} context */
-const create = () => ({
-	Literal(node) {
+const create = context => {
+	context.on('Literal', node => {
 		if (isStringLiteral(node)) {
 			return getProblem({
 				node,
 				original: node.raw,
 			});
 		}
+	});
 
+	context.on('Literal', node => {
 		if (isRegexLiteral(node)) {
 			return getProblem({
 				node,
 				original: node.raw,
 				regex: escapePatternWithLowercase,
 			});
 		}
-	},
-	TemplateElement(node) {
-		return getProblem({
-			node,
-			original: node.value.raw,
-			fix: (fixer, fixed) => replaceTemplateElement(fixer, node, fixed),
-		});
-	},
-});
+	});
+
+	context.on('TemplateElement', node => getProblem({
+		node,
+		original: node.value.raw,
+		fix: (fixer, fixed) => replaceTemplateElement(fixer, node, fixed),
+	}));
+};
 
 /** @type {import('eslint').Rule.RuleModule} */
 module.exports = {

rules/no-array-for-each.js

@@ -16,7 +16,7 @@ const isFunctionSelfUsedInside = require('./utils/is-function-self-used-inside.j
 const {isNodeMatches} = require('./utils/is-node-matches.js');
 const assertToken = require('./utils/assert-token.js');
 const {fixSpaceAroundKeyword, removeParentheses} = require('./fix/index.js');
-const {isArrowFunctionBody, isMethodCall, isReferenceIdentifier} = require('./ast/index.js');
+const {isArrowFunctionBody, isMethodCall, isReferenceIdentifier, functionTypes} = require('./ast/index.js');
 
 const MESSAGE_ID_ERROR = 'no-array-for-each/error';
 const MESSAGE_ID_SUGGESTION = 'no-array-for-each/suggestion';
@@ -381,74 +381,81 @@ const create = context => {
 	const functionInfo = new Map();
 	const {sourceCode} = context;
 
-	return {
-		':function'(node) {
-			functionStack.push(node);
-			functionInfo.set(node, {
-				returnStatements: [],
-				scope: sourceCode.getScope(node),
-			});
-		},
-		':function:exit'() {
-			functionStack.pop();
-		},
-		Identifier(node) {
-			if (isReferenceIdentifier(node)) {
-				allIdentifiers.push(node);
-			}
-		},
-		':function ReturnStatement'(node) {
-			const currentFunction = functionStack[functionStack.length - 1];
-			const {returnStatements} = functionInfo.get(currentFunction);
-			returnStatements.push(node);
-		},
-		CallExpression(node) {
-			if (
-				!isMethodCall(node, {
-					method: 'forEach',
-				})
-				|| isNodeMatches(node.callee.object, ignoredObjects)
-			) {
-				return;
-			}
+	context.on(functionTypes, node => {
+		functionStack.push(node);
+		functionInfo.set(node, {
+			returnStatements: [],
+			scope: sourceCode.getScope(node),
+		});
+	});
 
-			callExpressions.push({
-				node,
-				scope: sourceCode.getScope(node),
-			});
-		},
-		* 'Program:exit'() {
-			for (const {node, scope} of callExpressions) {
-				const iterable = node.callee;
-
-				const problem = {
-					node: iterable.property,
-					messageId: MESSAGE_ID_ERROR,
-				};
-
-				if (!isFixable(node, {scope, allIdentifiers, functionInfo, sourceCode})) {
-					yield problem;
-					continue;
-				}
-
-				const shouldUseSuggestion = iterable.optional && hasSideEffect(iterable, sourceCode);
-				const fix = getFixFunction(node, functionInfo, context);
-
-				if (shouldUseSuggestion) {
-					problem.suggest = [
-						{
-							messageId: MESSAGE_ID_SUGGESTION,
-							fix,
-						},
-					];
-				} else {
-					problem.fix = fix;
-				}
+	context.onExit(functionTypes, () => {
+		functionStack.pop();
+	});
+
+	context.on('Identifier', node => {
+		if (isReferenceIdentifier(node)) {
+			allIdentifiers.push(node);
+		}
+	});
+
+	context.on('ReturnStatement', node => {
+		const currentFunction = functionStack[functionStack.length - 1];
+		if (!currentFunction) {
+			return;
+		}
 
+		const {returnStatements} = functionInfo.get(currentFunction);
+		returnStatements.push(node);
+	});
+
+	context.on('CallExpression', node => {
+		if (
+			!isMethodCall(node, {
+				method: 'forEach',
+			})
+			|| isNodeMatches(node.callee.object, ignoredObjects)
+		) {
+			return;
+		}
+
+		callExpressions.push({
+			node,
+			scope: sourceCode.getScope(node),
+		});
+	});
+
+	context.onExit('Program', function * () {
+		for (const {node, scope} of callExpressions) {
+			const iterable = node.callee;
+
+			const problem = {
+				node: iterable.property,
+				messageId: MESSAGE_ID_ERROR,
+			};
+
+			if (!isFixable(node, {scope, allIdentifiers, functionInfo, sourceCode})) {
 				yield problem;
+				continue;
 			}
-		},
-	};
+
+			const shouldUseSuggestion = iterable.optional && hasSideEffect(iterable, sourceCode);
+			const fix = getFixFunction(node, functionInfo, context);
+
+			if (shouldUseSuggestion) {
+				problem.suggest = [
+					{
+						messageId: MESSAGE_ID_SUGGESTION,
+						fix,
+					},
+				];
+			} else {
+				problem.fix = fix;
+			}
+
+			yield problem;
+		}
+	});
 };
 
 /** @type {import('eslint').Rule.RuleModule} */