bahlint 28.58.6934

package/lib/rules/prefer-object-spread.js

@@ -0,0 +1,319 @@
+/**
+ * @fileoverview Rule to disallow using `Object.assign` with an object literal as the first argument and prefer the use of object spread instead
+ * @author Sharmila Jesupaul
+ */
+
+"use strict";
+
+const { CALL, ReferenceTracker } = require("@eslint-community/eslint-utils");
+const {
+	isCommaToken,
+	isOpeningParenToken,
+	isClosingParenToken,
+	isParenthesised,
+} = require("./utils/ast-utils");
+
+const ANY_SPACE = /\s/u;
+
+/**
+ * Helper that checks if the Object.assign call has array spread
+ * @param {ASTNode} node The node that the rule warns on
+ * @returns {boolean} - Returns true if the Object.assign call has array spread
+ */
+function hasArraySpread(node) {
+	return node.arguments.some(arg => arg.type === "SpreadElement");
+}
+
+/**
+ * Determines whether the given node is an accessor property (getter/setter).
+ * @param {ASTNode} node Node to check.
+ * @returns {boolean} `true` if the node is a getter or a setter.
+ */
+function isAccessorProperty(node) {
+	return (
+		node.type === "Property" && (node.kind === "get" || node.kind === "set")
+	);
+}
+
+/**
+ * Determines whether the given object expression node has accessor properties (getters/setters).
+ * @param {ASTNode} node `ObjectExpression` node to check.
+ * @returns {boolean} `true` if the node has at least one getter/setter.
+ */
+function hasAccessors(node) {
+	return node.properties.some(isAccessorProperty);
+}
+
+/**
+ * Determines whether the given call expression node has object expression arguments with accessor properties (getters/setters).
+ * @param {ASTNode} node `CallExpression` node to check.
+ * @returns {boolean} `true` if the node has at least one argument that is an object expression with at least one getter/setter.
+ */
+function hasArgumentsWithAccessors(node) {
+	return node.arguments
+		.filter(arg => arg.type === "ObjectExpression")
+		.some(hasAccessors);
+}
+
+/**
+ * Helper that checks if the node needs parentheses to be valid JS.
+ * The default is to wrap the node in parentheses to avoid parsing errors.
+ * @param {ASTNode} node The node that the rule warns on
+ * @param {Object} sourceCode in context sourcecode object
+ * @returns {boolean} - Returns true if the node needs parentheses
+ */
+function needsParens(node, sourceCode) {
+	const parent = node.parent;
+
+	switch (parent.type) {
+		case "VariableDeclarator":
+		case "ArrayExpression":
+		case "ReturnStatement":
+		case "CallExpression":
+		case "Property":
+			return false;
+		case "AssignmentExpression":
+			return parent.left === node && !isParenthesised(sourceCode, node);
+		default:
+			return !isParenthesised(sourceCode, node);
+	}
+}
+
+/**
+ * Determines if an argument needs parentheses. The default is to not add parens.
+ * @param {ASTNode} node The node to be checked.
+ * @param {Object} sourceCode in context sourcecode object
+ * @returns {boolean} True if the node needs parentheses
+ */
+function argNeedsParens(node, sourceCode) {
+	switch (node.type) {
+		case "AssignmentExpression":
+		case "ArrowFunctionExpression":
+		case "ConditionalExpression":
+			return !isParenthesised(sourceCode, node);
+		default:
+			return false;
+	}
+}
+
+/**
+ * Get the parenthesis tokens of a given ObjectExpression node.
+ * This includes the braces of the object literal and enclosing parentheses.
+ * @param {ASTNode} node The node to get.
+ * @param {Token} leftArgumentListParen The opening paren token of the argument list.
+ * @param {SourceCode} sourceCode The source code object to get tokens.
+ * @returns {Token[]} The parenthesis tokens of the node. This is sorted by the location.
+ */
+function getParenTokens(node, leftArgumentListParen, sourceCode) {
+	const parens = [
+		sourceCode.getFirstToken(node),
+		sourceCode.getLastToken(node),
+	];
+	let leftNext = sourceCode.getTokenBefore(node);
+	let rightNext = sourceCode.getTokenAfter(node);
+
+	// Note: don't include the parens of the argument list.
+	while (
+		leftNext &&
+		rightNext &&
+		leftNext.range[0] > leftArgumentListParen.range[0] &&
+		isOpeningParenToken(leftNext) &&
+		isClosingParenToken(rightNext)
+	) {
+		parens.push(leftNext, rightNext);
+		leftNext = sourceCode.getTokenBefore(leftNext);
+		rightNext = sourceCode.getTokenAfter(rightNext);
+	}
+
+	return parens.sort((a, b) => a.range[0] - b.range[0]);
+}
+
+/**
+ * Get the range of a given token and around whitespaces.
+ * @param {Token} token The token to get range.
+ * @param {SourceCode} sourceCode The source code object to get tokens.
+ * @returns {number} The end of the range of the token and around whitespaces.
+ */
+function getStartWithSpaces(token, sourceCode) {
+	const text = sourceCode.text;
+	let start = token.range[0];
+
+	// If the previous token is a line comment then skip this step to avoid commenting this token out.
+	{
+		const prevToken = sourceCode.getTokenBefore(token, {
+			includeComments: true,
+		});
+
+		if (prevToken && prevToken.type === "Line") {
+			return start;
+		}
+	}
+
+	// Detect spaces before the token.
+	while (ANY_SPACE.test(text[start - 1] || "")) {
+		start -= 1;
+	}
+
+	return start;
+}
+
+/**
+ * Get the range of a given token and around whitespaces.
+ * @param {Token} token The token to get range.
+ * @param {SourceCode} sourceCode The source code object to get tokens.
+ * @returns {number} The start of the range of the token and around whitespaces.
+ */
+function getEndWithSpaces(token, sourceCode) {
+	const text = sourceCode.text;
+	let end = token.range[1];
+
+	// Detect spaces after the token.
+	while (ANY_SPACE.test(text[end] || "")) {
+		end += 1;
+	}
+
+	return end;
+}
+
+/**
+ * Autofixes the Object.assign call to use an object spread instead.
+ * @param {ASTNode|null} node The node that the rule warns on, i.e. the Object.assign call
+ * @param {string} sourceCode sourceCode of the Object.assign call
+ * @returns {Function} autofixer - replaces the Object.assign with a spread object.
+ */
+function defineFixer(node, sourceCode) {
+	return function* (fixer) {
+		const leftParen = sourceCode.getTokenAfter(
+			node.callee,
+			isOpeningParenToken,
+		);
+		const rightParen = sourceCode.getLastToken(node);
+
+		// Remove everything before the opening paren: callee `Object.assign`, type arguments, and whitespace between the callee and the paren.
+		yield fixer.removeRange([node.range[0], leftParen.range[0]]);
+
+		// Replace the parens of argument list to braces.
+		if (needsParens(node, sourceCode)) {
+			yield fixer.replaceText(leftParen, "({");
+			yield fixer.replaceText(rightParen, "})");
+		} else {
+			yield fixer.replaceText(leftParen, "{");
+			yield fixer.replaceText(rightParen, "}");
+		}
+
+		// Process arguments.
+		for (const argNode of node.arguments) {
+			const innerParens = getParenTokens(argNode, leftParen, sourceCode);
+			const left = innerParens.shift();
+			const right = innerParens.pop();
+
+			if (argNode.type === "ObjectExpression") {
+				const maybeTrailingComma = sourceCode.getLastToken(argNode, 1);
+				const maybeArgumentComma = sourceCode.getTokenAfter(right);
+
+				/*
+				 * Make bare this object literal.
+				 * And remove spaces inside of the braces for better formatting.
+				 */
+				for (const innerParen of innerParens) {
+					yield fixer.remove(innerParen);
+				}
+				const leftRange = [
+					left.range[0],
+					getEndWithSpaces(left, sourceCode),
+				];
+				const rightRange = [
+					Math.max(
+						getStartWithSpaces(right, sourceCode),
+						leftRange[1],
+					), // Ensure ranges don't overlap
+					right.range[1],
+				];
+
+				yield fixer.removeRange(leftRange);
+				yield fixer.removeRange(rightRange);
+
+				// Remove the comma of this argument if it's duplication.
+				if (
+					(argNode.properties.length === 0 ||
+						isCommaToken(maybeTrailingComma)) &&
+					isCommaToken(maybeArgumentComma)
+				) {
+					yield fixer.remove(maybeArgumentComma);
+				}
+			} else {
+				// Make spread.
+				if (argNeedsParens(argNode, sourceCode)) {
+					yield fixer.insertTextBefore(left, "...(");
+					yield fixer.insertTextAfter(right, ")");
+				} else {
+					yield fixer.insertTextBefore(left, "...");
+				}
+			}
+		}
+	};
+}
+
+/** @type {import('../types').Rule.RuleModule} */
+module.exports = {
+	meta: {
+		type: "suggestion",
+
+		docs: {
+			description:
+				"Disallow using `Object.assign` with an object literal as the first argument and prefer the use of object spread instead",
+			recommended: false,
+			frozen: true,
+			url: "https://eslint.org/docs/latest/rules/prefer-object-spread",
+		},
+
+		schema: [],
+		fixable: "code",
+
+		messages: {
+			useSpreadMessage:
+				"Use an object spread instead of `Object.assign` eg: `{ ...foo }`.",
+			useLiteralMessage:
+				"Use an object literal instead of `Object.assign`. eg: `{ foo: bar }`.",
+		},
+	},
+
+	create(context) {
+		const sourceCode = context.sourceCode;
+
+		return {
+			Program(node) {
+				const scope = sourceCode.getScope(node);
+				const tracker = new ReferenceTracker(scope);
+				const trackMap = {
+					Object: {
+						assign: { [CALL]: true },
+					},
+				};
+
+				// Iterate all calls of `Object.assign` (only of the global variable `Object`).
+				for (const { node: refNode } of tracker.iterateGlobalReferences(
+					trackMap,
+				)) {
+					if (
+						refNode.arguments.length >= 1 &&
+						refNode.arguments[0].type === "ObjectExpression" &&
+						!hasArraySpread(refNode) &&
+						!(
+							refNode.arguments.length > 1 &&
+							hasArgumentsWithAccessors(refNode)
+						)
+					) {
+						const messageId =
+							refNode.arguments.length === 1
+								? "useLiteralMessage"
+								: "useSpreadMessage";
+						const fix = defineFixer(refNode, sourceCode);
+
+						context.report({ node: refNode, messageId, fix });
+					}
+				}
+			},
+		};
+	},
+};

package/lib/rules/prefer-promise-reject-errors.js

@@ -0,0 +1,154 @@
+/**
+ * @fileoverview restrict values that can be used as Promise rejection reasons
+ * @author Teddy Katz
+ */
+"use strict";
+
+const astUtils = require("./utils/ast-utils");
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../types').Rule.RuleModule} */
+module.exports = {
+	meta: {
+		type: "suggestion",
+
+		defaultOptions: [
+			{
+				allowEmptyReject: false,
+			},
+		],
+
+		docs: {
+			description:
+				"Require using Error objects as Promise rejection reasons",
+			recommended: false,
+			url: "https://eslint.org/docs/latest/rules/prefer-promise-reject-errors",
+		},
+
+		fixable: null,
+
+		schema: [
+			{
+				type: "object",
+				properties: {
+					allowEmptyReject: { type: "boolean" },
+				},
+				additionalProperties: false,
+			},
+		],
+
+		messages: {
+			rejectAnError:
+				"Expected the Promise rejection reason to be an Error.",
+		},
+	},
+
+	create(context) {
+		const [{ allowEmptyReject }] = context.options;
+		const sourceCode = context.sourceCode;
+
+		//----------------------------------------------------------------------
+		// Helpers
+		//----------------------------------------------------------------------
+
+		/**
+		 * Checks the argument of a reject() or Promise.reject() CallExpression, and reports it if it can't be an Error
+		 * @param {ASTNode} callExpression A CallExpression node which is used to reject a Promise
+		 * @returns {void}
+		 */
+		function checkRejectCall(callExpression) {
+			if (!callExpression.arguments.length && allowEmptyReject) {
+				return;
+			}
+			if (
+				!callExpression.arguments.length ||
+				!astUtils.couldBeError(callExpression.arguments[0]) ||
+				(callExpression.arguments[0].type === "Identifier" &&
+					callExpression.arguments[0].name === "undefined")
+			) {
+				context.report({
+					node: callExpression,
+					messageId: "rejectAnError",
+				});
+			}
+		}
+
+		/**
+		 * Determines whether a function call is a Promise.reject() call
+		 * @param {ASTNode} node A CallExpression node
+		 * @returns {boolean} `true` if the call is a Promise.reject() call
+		 */
+		function isPromiseRejectCall(node) {
+			return astUtils.isSpecificMemberAccess(
+				node.callee,
+				"Promise",
+				"reject",
+			);
+		}
+
+		//----------------------------------------------------------------------
+		// Public
+		//----------------------------------------------------------------------
+
+		return {
+			// Check `Promise.reject(value)` calls.
+			CallExpression(node) {
+				if (isPromiseRejectCall(node)) {
+					checkRejectCall(node);
+				}
+			},
+
+			/*
+			 * Check for `new Promise((resolve, reject) => {})`, and check for reject() calls.
+			 * This function is run on "NewExpression:exit" instead of "NewExpression" to ensure that
+			 * the nodes in the expression already have the `parent` property.
+			 */
+			"NewExpression:exit"(node) {
+				if (
+					node.callee.type === "Identifier" &&
+					node.callee.name === "Promise" &&
+					node.arguments.length &&
+					astUtils.isFunction(node.arguments[0]) &&
+					node.arguments[0].params.length > 1 &&
+					node.arguments[0].params[1].type === "Identifier"
+				) {
+					sourceCode
+						.getDeclaredVariables(node.arguments[0])
+
+						/*
+						 * Find the first variable that matches the second parameter's name.
+						 * If the first parameter has the same name as the second parameter, then the variable will actually
+						 * be "declared" when the first parameter is evaluated, but then it will be immediately overwritten
+						 * by the second parameter. It's not possible for an expression with the variable to be evaluated before
+						 * the variable is overwritten, because functions with duplicate parameters cannot have destructuring or
+						 * default assignments in their parameter lists. Therefore, it's not necessary to explicitly account for
+						 * this case.
+						 */
+						.find(
+							variable =>
+								variable.name ===
+								node.arguments[0].params[1].name,
+						)
+
+						// Get the references to that variable.
+						.references // Only check the references that read the parameter's value.
+						.filter(ref => ref.isRead())
+
+						// Only check the references that are used as the callee in a function call, e.g. `reject(foo)`.
+						.filter(
+							ref =>
+								ref.identifier.parent.type ===
+									"CallExpression" &&
+								ref.identifier === ref.identifier.parent.callee,
+						)
+
+						// Check the argument of the function call to determine whether it's an Error.
+						.forEach(ref => checkRejectCall(ref.identifier.parent));
+				}
+			},
+		};
+	},
+};

package/lib/rules/prefer-reflect.js

@@ -0,0 +1,150 @@
+/**
+ * @fileoverview Rule to suggest using "Reflect" api over Function/Object methods
+ * @author Keith Cirkel <http://keithcirkel.co.uk>
+ * @deprecated in ESLint v3.9.0
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../types').Rule.RuleModule} */
+module.exports = {
+	meta: {
+		type: "suggestion",
+
+		docs: {
+			description: "Require `Reflect` methods where applicable",
+			recommended: false,
+			url: "https://eslint.org/docs/latest/rules/prefer-reflect",
+		},
+
+		deprecated: {
+			message: "The original intention of this rule was misguided.",
+			deprecatedSince: "3.9.0",
+			availableUntil: null,
+			replacedBy: [],
+		},
+
+		schema: [
+			{
+				type: "object",
+				properties: {
+					exceptions: {
+						type: "array",
+						items: {
+							enum: [
+								"apply",
+								"call",
+								"delete",
+								"defineProperty",
+								"getOwnPropertyDescriptor",
+								"getPrototypeOf",
+								"setPrototypeOf",
+								"isExtensible",
+								"getOwnPropertyNames",
+								"preventExtensions",
+							],
+						},
+						uniqueItems: true,
+					},
+				},
+				additionalProperties: false,
+			},
+		],
+
+		messages: {
+			preferReflect:
+				"Avoid using {{existing}}, instead use {{substitute}}.",
+		},
+	},
+
+	create(context) {
+		const existingNames = {
+			apply: "Function.prototype.apply",
+			call: "Function.prototype.call",
+			defineProperty: "Object.defineProperty",
+			getOwnPropertyDescriptor: "Object.getOwnPropertyDescriptor",
+			getPrototypeOf: "Object.getPrototypeOf",
+			setPrototypeOf: "Object.setPrototypeOf",
+			isExtensible: "Object.isExtensible",
+			getOwnPropertyNames: "Object.getOwnPropertyNames",
+			preventExtensions: "Object.preventExtensions",
+		};
+
+		const reflectSubstitutes = {
+			apply: "Reflect.apply",
+			call: "Reflect.apply",
+			defineProperty: "Reflect.defineProperty",
+			getOwnPropertyDescriptor: "Reflect.getOwnPropertyDescriptor",
+			getPrototypeOf: "Reflect.getPrototypeOf",
+			setPrototypeOf: "Reflect.setPrototypeOf",
+			isExtensible: "Reflect.isExtensible",
+			getOwnPropertyNames: "Reflect.getOwnPropertyNames",
+			preventExtensions: "Reflect.preventExtensions",
+		};
+
+		const exceptions = (context.options[0] || {}).exceptions || [];
+
+		/**
+		 * Reports the Reflect violation based on the `existing` and `substitute`
+		 * @param {Object} node The node that violates the rule.
+		 * @param {string} existing The existing method name that has been used.
+		 * @param {string} substitute The Reflect substitute that should be used.
+		 * @returns {void}
+		 */
+		function report(node, existing, substitute) {
+			context.report({
+				node,
+				messageId: "preferReflect",
+				data: {
+					existing,
+					substitute,
+				},
+			});
+		}
+
+		return {
+			CallExpression(node) {
+				const methodName = (node.callee.property || {}).name;
+				const isReflectCall =
+					(node.callee.object || {}).name === "Reflect";
+				const hasReflectSubstitute = Object.hasOwn(
+					reflectSubstitutes,
+					methodName,
+				);
+				const userConfiguredException = exceptions.includes(methodName);
+
+				if (
+					hasReflectSubstitute &&
+					!isReflectCall &&
+					!userConfiguredException
+				) {
+					report(
+						node,
+						existingNames[methodName],
+						reflectSubstitutes[methodName],
+					);
+				}
+			},
+			UnaryExpression(node) {
+				const isDeleteOperator = node.operator === "delete";
+				const targetsIdentifier = node.argument.type === "Identifier";
+				const userConfiguredException = exceptions.includes("delete");
+
+				if (
+					isDeleteOperator &&
+					!targetsIdentifier &&
+					!userConfiguredException
+				) {
+					report(
+						node,
+						"the delete keyword",
+						"Reflect.deleteProperty",
+					);
+				}
+			},
+		};
+	},
+};