Add AST utils (#1769)

Author: fisker

rules/ast/index.js

@@ -1,5 +1,24 @@
 'use strict';
+
+const {
+	isLiteral,
+	isStringLiteral,
+	isNumberLiteral,
+	isBigIntLiteral,
+	isNullLiteral,
+	isRegexLiteral,
+} = require('./literal.js');
+
 module.exports = {
+	isLiteral,
+	isStringLiteral,
+	isNumberLiteral,
+	isBigIntLiteral,
+	isNullLiteral,
+	isRegexLiteral,
+
 	isArrowFunctionBody: require('./is-arrow-function-body.js'),
 	isEmptyNode: require('./is-empty-node.js'),
+	isStaticRequire: require('./is-static-require.js'),
+	isUndefined: require('./is-undefined.js'),
 };

rules/utils/is-static-require.js rules/ast/is-static-require.jsrules/utils/is-static-require.js renamed to rules/ast/is-static-require.js

@@ -1,5 +1,7 @@
 'use strict';
 
+const {isStringLiteral} = require('./literal.js');
+
 const isStaticRequire = node => Boolean(
 	node
 	&& node.type === 'CallExpression'
@@ -8,8 +10,7 @@ const isStaticRequire = node => Boolean(
 	&& node.callee.name === 'require'
 	&& !node.optional
 	&& node.arguments.length === 1
-	&& node.arguments[0].type === 'Literal'
-	&& typeof node.arguments[0].value === 'string',
+	&& isStringLiteral(node.arguments[0]),
 );
 
 module.exports = isStaticRequire;

rules/ast/is-undefined.js

@@ -0,0 +1,7 @@
+'use strict';
+
+function isUndefined(node) {
+	return node.type === 'Identifier' && node.name === 'undefined';
+}
+
+module.exports = isUndefined;

rules/ast/literal.js

@@ -0,0 +1,29 @@
+'use strict';
+
+function isLiteral(node, value) {
+	if (node?.type !== 'Literal') {
+		return false;
+	}
+
+	if (value === null) {
+		return node.raw === 'null';
+	}
+
+	return node.value === value;
+}
+
+const isStringLiteral = node => node?.type === 'Literal' && typeof node.value === 'string';
+const isNumberLiteral = node => node.type === 'Literal' && typeof node.value === 'number';
+const isRegexLiteral = node => node.type === 'Literal' && Boolean(node.regex);
+// eslint-disable-next-line unicorn/no-null
+const isNullLiteral = node => isLiteral(node, null);
+const isBigIntLiteral = node => node.type === 'Literal' && Boolean(node.bigint);
+
+module.exports = {
+	isLiteral,
+	isStringLiteral,
+	isNumberLiteral,
+	isBigIntLiteral,
+	isNullLiteral,
+	isRegexLiteral,
+};

rules/better-regex.js

@@ -3,16 +3,14 @@ const cleanRegexp = require('clean-regexp');
 const {optimize} = require('regexp-tree');
 const quoteString = require('./utils/quote-string.js');
 const {newExpressionSelector} = require('./selectors/index.js');
+const {isStringLiteral} = require('./ast/index.js');
 
 const MESSAGE_ID = 'better-regex';
 const messages = {
 	[MESSAGE_ID]: '{{original}} can be optimized to {{optimized}}.',
 };
 
-const newRegExp = [
-	newExpressionSelector({name: 'RegExp', minimumArguments: 1}),
-	'[arguments.0.type="Literal"]',
-].join('');
+const newRegExp = newExpressionSelector({name: 'RegExp', minimumArguments: 1});
 
 /** @param {import('eslint').Rule.RuleContext} context */
 const create = context => {
@@ -66,16 +64,12 @@ const create = context => {
 		[newRegExp](node) {
 			const [patternNode, flagsNode] = node.arguments;
 
-			if (typeof patternNode.value !== 'string') {
+			if (!isStringLiteral(patternNode)) {
 				return;
 			}
 
 			const oldPattern = patternNode.value;
-			const flags = (
-				flagsNode
-				&& flagsNode.type === 'Literal'
-				&& typeof flagsNode.value === 'string'
-			)
+			const flags = isStringLiteral(flagsNode)
 				? flagsNode.value
 				: '';
 

rules/consistent-function-scoping.js

@@ -109,7 +109,6 @@ const iifeFunctionTypes = new Set([
 ]);
 const isIife = node => node
 	&& iifeFunctionTypes.has(node.type)
-	&& node.parent
 	&& node.parent.type === 'CallExpression'
 	&& node.parent.callee === node;
 

rules/explicit-length-check.js

@@ -1,11 +1,11 @@
 'use strict';
 const {isParenthesized, getStaticValue} = require('eslint-utils');
 const {checkVueTemplate} = require('./utils/rule.js');
-const isLiteralValue = require('./utils/is-literal-value.js');
 const isLogicalExpression = require('./utils/is-logical-expression.js');
 const {isBooleanNode, getBooleanAncestor} = require('./utils/boolean.js');
 const {memberExpressionSelector} = require('./selectors/index.js');
 const {fixSpaceAroundKeyword} = require('./fix/index.js');
+const {isLiteral} = require('./ast/index.js');
 
 const TYPE_NON_ZERO = 'non-zero';
 const TYPE_ZERO = 'zero';
@@ -19,11 +19,11 @@ const messages = {
 const isCompareRight = (node, operator, value) =>
 	node.type === 'BinaryExpression'
 	&& node.operator === operator
-	&& isLiteralValue(node.right, value);
+	&& isLiteral(node.right, value);
 const isCompareLeft = (node, operator, value) =>
 	node.type === 'BinaryExpression'
 	&& node.operator === operator
-	&& isLiteralValue(node.left, value);
+	&& isLiteral(node.left, value);
 const nonZeroStyles = new Map([
 	[
 		'greater-than',

rules/no-await-expression-member.js

@@ -3,6 +3,7 @@ const {
 	removeParentheses,
 	removeMemberExpressionProperty,
 } = require('./fix/index.js');
+const {isLiteral} = require('./ast/index.js');
 
 const MESSAGE_ID = 'no-await-expression-member';
 const messages = {
@@ -25,8 +26,7 @@ const create = context => {
 			if (
 				memberExpression.computed
 				&& !memberExpression.optional
-				&& property.type === 'Literal'
-				&& (property.value === 0 || property.value === 1)
+				&& (isLiteral(property, 0) || isLiteral(property, 1))
 				&& memberExpression.parent.type === 'VariableDeclarator'
 				&& memberExpression.parent.init === memberExpression
 				&& memberExpression.parent.id.type === 'Identifier'

rules/no-console-spaces.js

@@ -1,6 +1,7 @@
 'use strict';
 const {methodCallSelector} = require('./selectors/index.js');
 const toLocation = require('./utils/to-location.js');
+const {isStringLiteral} = require('./ast/index.js');
 
 const MESSAGE_ID = 'no-console-spaces';
 const messages = {
@@ -50,11 +51,7 @@ const create = context => {
 			const {arguments: messages} = node;
 			const {length} = messages;
 			for (const [index, node] of messages.entries()) {
-				const {type, value} = node;
-				if (
-					!(type === 'Literal' && typeof value === 'string')
-					&& type !== 'TemplateLiteral'
-				) {
+				if (!isStringLiteral(node) && node.type !== 'TemplateLiteral') {
 					continue;
 				}
 

rules/no-for-loop.js

@@ -1,20 +1,20 @@
 'use strict';
 const {isClosingParenToken, getStaticValue} = require('eslint-utils');
-const isLiteralValue = require('./utils/is-literal-value.js');
 const avoidCapture = require('./utils/avoid-capture.js');
 const getScopes = require('./utils/get-scopes.js');
 const singular = require('./utils/singular.js');
 const toLocation = require('./utils/to-location.js');
 const getReferences = require('./utils/get-references.js');
+const {isLiteral} = require('./ast/index.js');
 
 const MESSAGE_ID = 'no-for-loop';
 const messages = {
 	[MESSAGE_ID]: 'Use a `for-of` loop instead of this `for` loop.',
 };
 
 const defaultElementName = 'element';
-const isLiteralZero = node => isLiteralValue(node, 0);
-const isLiteralOne = node => isLiteralValue(node, 1);
+const isLiteralZero = node => isLiteral(node, 0);
+const isLiteralOne = node => isLiteral(node, 1);
 
 const isIdentifierWithName = (node, name) => node && node.type === 'Identifier' && node.name === name;