Remove use of memberExpressionSelector (#2120)

Author: fisker

rules/no-useless-length-check.js

@@ -1,34 +1,23 @@
 'use strict';
-const {isMethodCall} = require('./ast/index.js');
-const {matches, memberExpressionSelector} = require('./selectors/index.js');
-const {getParenthesizedRange, isSameReference} = require('./utils/index.js');
+const {isMethodCall, isMemberExpression} = require('./ast/index.js');
+const {
+	getParenthesizedRange,
+	isSameReference,
+	isLogicalExpression,
+} = require('./utils/index.js');
 
 const messages = {
 	'non-zero': 'The non-empty check is useless as `Array#some()` returns `false` for an empty array.',
 	zero: 'The empty check is useless as `Array#every()` returns `true` for an empty array.',
 };
 
-const logicalExpressionSelector = [
-	'LogicalExpression',
-	matches(['[operator="||"]', '[operator="&&"]']),
-].join('');
 // We assume the user already follows `unicorn/explicit-length-check`. These are allowed in that rule.
-const lengthCompareZeroSelector = [
-	logicalExpressionSelector,
-	' > ',
-	'BinaryExpression',
-	memberExpressionSelector({path: 'left', property: 'length'}),
-	'[right.type="Literal"]',
-	'[right.raw="0"]',
-].join('');
-const zeroLengthCheckSelector = [
-	lengthCompareZeroSelector,
-	'[operator="==="]',
-].join('');
-const nonZeroLengthCheckSelector = [
-	lengthCompareZeroSelector,
-	matches(['[operator=">"]', '[operator="!=="]']),
-].join('');
+const isLengthCompareZero = node =>
+	node.type === 'BinaryExpression'
+	&& node.right.type === 'Literal'
+	&& node.right.raw === '0'
+	&& isMemberExpression(node.left, {property: 'length', optional: false})
+	&& isLogicalExpression(node.parent);
 
 function flatLogicalExpression(node) {
 	return [node.left, node.right].flatMap(child =>
@@ -81,11 +70,15 @@ const create = context => {
 	}
 
 	return {
-		[zeroLengthCheckSelector](node) {
-			zeroLengthChecks.add(node);
-		},
-		[nonZeroLengthCheckSelector](node) {
-			nonZeroLengthChecks.add(node);
+		BinaryExpression(node) {
+			if (isLengthCompareZero(node)) {
+				const {operator} = node;
+				if (operator === '===') {
+					zeroLengthChecks.add(node);
+				} else if (operator === '>' || operator === '!==') {
+					nonZeroLengthChecks.add(node);
+				}
+			}
 		},
 		CallExpression(node) {
 			if (
@@ -103,8 +96,10 @@ const create = context => {
 				}
 			}
 		},
-		[logicalExpressionSelector](node) {
-			logicalExpressions.push(node);
+		LogicalExpression(node) {
+			if (isLogicalExpression(node)) {
+				logicalExpressions.push(node);
+			}
 		},
 		* 'Program:exit'() {
 			const nodes = new Set(

rules/prefer-top-level-await.js

@@ -1,6 +1,6 @@
 'use strict';
 const {findVariable, getFunctionHeadLocation} = require('@eslint-community/eslint-utils');
-const {matches, not, memberExpressionSelector} = require('./selectors/index.js');
+const {isFunction, isMemberExpression} = require('./ast/index.js');
 
 const ERROR_PROMISE = 'promise';
 const ERROR_IIFE = 'iife';
@@ -14,32 +14,23 @@ const messages = {
 };
 
 const promiseMethods = ['then', 'catch', 'finally'];
+const isTopLevelCallExpression = node => {
+	if (node.type !== 'CallExpression') {
+		return false;
+	}
 
-const topLevelCallExpression = [
-	'CallExpression',
-	not([':function *', 'ClassDeclaration *', 'ClassExpression *']),
-].join('');
-const iife = [
-	topLevelCallExpression,
-	matches([
-		'[callee.type="FunctionExpression"]',
-		'[callee.type="ArrowFunctionExpression"]',
-	]),
-	'[callee.async!=false]',
-	'[callee.generator!=true]',
-].join('');
-const promise = [
-	topLevelCallExpression,
-	memberExpressionSelector({
-		path: 'callee',
-		properties: promiseMethods,
-		includeOptional: true,
-	}),
-].join('');
-const identifier = [
-	topLevelCallExpression,
-	'[callee.type="Identifier"]',
-].join('');
+	for (let ancestor = node.parent; ancestor; ancestor = ancestor.parent) {
+		if (
+			isFunction(ancestor)
+			|| ancestor.type === 'ClassDeclaration'
+			|| ancestor.type === 'ClassExpression'
+		) {
+			return false;
+		}
+	}
+
+	return true;
+};
 
 const isPromiseMethodCalleeObject = node =>
 	node.parent.type === 'MemberExpression'
@@ -63,32 +54,44 @@ function create(context) {
 		return;
 	}
 
-	const {sourceCode} = context;
-
 	return {
-		[promise](node) {
-			if (isPromiseMethodCalleeObject(node) || isAwaitArgument(node)) {
+		CallExpression(node) {
+			if (
+				!isTopLevelCallExpression(node)
+				|| isPromiseMethodCalleeObject(node)
+				|| isAwaitArgument(node)
+			) {
 				return;
 			}
 
-			return {
-				node: node.callee.property,
-				messageId: ERROR_PROMISE,
-			};
-		},
-		[iife](node) {
-			if (isPromiseMethodCalleeObject(node) || isAwaitArgument(node)) {
-				return;
+			// Promises
+			if (isMemberExpression(node.callee, {
+				properties: promiseMethods,
+				computed: false,
+			})) {
+				return {
+					node: node.callee.property,
+					messageId: ERROR_PROMISE,
+				};
 			}
 
-			return {
-				node,
-				loc: getFunctionHeadLocation(node.callee, sourceCode),
-				messageId: ERROR_IIFE,
-			};
-		},
-		[identifier](node) {
-			if (isPromiseMethodCalleeObject(node) || isAwaitArgument(node)) {
+			const {sourceCode} = context;
+
+			// IIFE
+			if (
+				(node.callee.type === 'FunctionExpression' || node.callee.type === 'ArrowFunctionExpression')
+				&& node.callee.async
+				&& !node.callee.generator
+			) {
+				return {
+					node,
+					loc: getFunctionHeadLocation(node.callee, sourceCode),
+					messageId: ERROR_IIFE,
+				};
+			}
+
+			// Identifier
+			if (node.callee.type !== 'Identifier') {
 				return;
 			}
 

rules/selectors/index.js

@@ -5,7 +5,6 @@ module.exports = {
 	matches: require('./matches-any.js'),
 	not: require('./negation.js'),
 
-	memberExpressionSelector: require('./member-expression-selector.js'),
 	methodCallSelector: require('./method-call-selector.js'),
 	callExpressionSelector: require('./call-or-new-expression-selector.js').callExpressionSelector,
 	newExpressionSelector: require('./call-or-new-expression-selector.js').newExpressionSelector,

rules/utils/index.js

@@ -24,6 +24,7 @@ module.exports = {
 	getVariableIdentifiers: require('./get-variable-identifiers.js'),
 	isArrayPrototypeProperty,
 	isBooleanNode,
+	isLogicalExpression: require('./is-logical-expression.js'),
 	isNodeMatches,
 	isNodeMatchesNameOrPath,
 	isNodeValueNotDomNode: require('./is-node-value-not-dom-node.js'),