eslint 8.57.1 → 9.39.1

package/lib/rules/no-import-assign.js

@@ -13,8 +13,8 @@ const { findVariable } = require("@eslint-community/eslint-utils");
 const astUtils = require("./utils/ast-utils");
 
 const WellKnownMutationFunctions = {
-    Object: /^(?:assign|definePropert(?:y|ies)|freeze|setPrototypeOf)$/u,
-    Reflect: /^(?:(?:define|delete)Property|set(?:PrototypeOf)?)$/u
+	Object: /^(?:assign|definePropert(?:y|ies)|freeze|setPrototypeOf)$/u,
+	Reflect: /^(?:(?:define|delete)Property|set(?:PrototypeOf)?)$/u,
 };
 
 /**
@@ -23,27 +23,18 @@ const WellKnownMutationFunctions = {
  * @returns {boolean} `true` if the node is LHS.
  */
 function isAssignmentLeft(node) {
-    const { parent } = node;
-
-    return (
-        (
-            parent.type === "AssignmentExpression" &&
-            parent.left === node
-        ) ||
-
-        // Destructuring assignments
-        parent.type === "ArrayPattern" ||
-        (
-            parent.type === "Property" &&
-            parent.value === node &&
-            parent.parent.type === "ObjectPattern"
-        ) ||
-        parent.type === "RestElement" ||
-        (
-            parent.type === "AssignmentPattern" &&
-            parent.left === node
-        )
-    );
+	const { parent } = node;
+
+	return (
+		(parent.type === "AssignmentExpression" && parent.left === node) ||
+		// Destructuring assignments
+		parent.type === "ArrayPattern" ||
+		(parent.type === "Property" &&
+			parent.value === node &&
+			parent.parent.type === "ObjectPattern") ||
+		parent.type === "RestElement" ||
+		(parent.type === "AssignmentPattern" && parent.left === node)
+	);
 }
 
 /**
@@ -52,22 +43,17 @@ function isAssignmentLeft(node) {
  * @returns {boolean} `true` if the node is the operand of mutation unary operator.
  */
 function isOperandOfMutationUnaryOperator(node) {
-    const argumentNode = node.parent.type === "ChainExpression"
-        ? node.parent
-        : node;
-    const { parent } = argumentNode;
-
-    return (
-        (
-            parent.type === "UpdateExpression" &&
-            parent.argument === argumentNode
-        ) ||
-        (
-            parent.type === "UnaryExpression" &&
-            parent.operator === "delete" &&
-            parent.argument === argumentNode
-        )
-    );
+	const argumentNode =
+		node.parent.type === "ChainExpression" ? node.parent : node;
+	const { parent } = argumentNode;
+
+	return (
+		(parent.type === "UpdateExpression" &&
+			parent.argument === argumentNode) ||
+		(parent.type === "UnaryExpression" &&
+			parent.operator === "delete" &&
+			parent.argument === argumentNode)
+	);
 }
 
 /**
@@ -76,18 +62,12 @@ function isOperandOfMutationUnaryOperator(node) {
  * @returns {boolean} `true` if the node is the iteration variable.
  */
 function isIterationVariable(node) {
-    const { parent } = node;
-
-    return (
-        (
-            parent.type === "ForInStatement" &&
-            parent.left === node
-        ) ||
-        (
-            parent.type === "ForOfStatement" &&
-            parent.left === node
-        )
-    );
+	const { parent } = node;
+
+	return (
+		(parent.type === "ForInStatement" && parent.left === node) ||
+		(parent.type === "ForOfStatement" && parent.left === node)
+	);
 }
 
 /**
@@ -106,22 +86,30 @@ function isIterationVariable(node) {
  * @returns {boolean} `true` if the node is at the first argument of a well-known mutation function.
  */
 function isArgumentOfWellKnownMutationFunction(node, scope) {
-    const { parent } = node;
-
-    if (parent.type !== "CallExpression" || parent.arguments[0] !== node) {
-        return false;
-    }
-    const callee = astUtils.skipChainExpression(parent.callee);
-
-    if (
-        !astUtils.isSpecificMemberAccess(callee, "Object", WellKnownMutationFunctions.Object) &&
-        !astUtils.isSpecificMemberAccess(callee, "Reflect", WellKnownMutationFunctions.Reflect)
-    ) {
-        return false;
-    }
-    const variable = findVariable(scope, callee.object);
-
-    return variable !== null && variable.scope.type === "global";
+	const { parent } = node;
+
+	if (parent.type !== "CallExpression" || parent.arguments[0] !== node) {
+		return false;
+	}
+	const callee = astUtils.skipChainExpression(parent.callee);
+
+	if (
+		!astUtils.isSpecificMemberAccess(
+			callee,
+			"Object",
+			WellKnownMutationFunctions.Object,
+		) &&
+		!astUtils.isSpecificMemberAccess(
+			callee,
+			"Reflect",
+			WellKnownMutationFunctions.Reflect,
+		)
+	) {
+		return false;
+	}
+	const variable = findVariable(scope, callee.object);
+
+	return variable !== null && variable.scope.type === "global";
 }
 
 /**
@@ -131,20 +119,16 @@ function isArgumentOfWellKnownMutationFunction(node, scope) {
  * @returns {boolean} `true` if the member of `id` was updated.
  */
 function isMemberWrite(id, scope) {
-    const { parent } = id;
-
-    return (
-        (
-            parent.type === "MemberExpression" &&
-            parent.object === id &&
-            (
-                isAssignmentLeft(parent) ||
-                isOperandOfMutationUnaryOperator(parent) ||
-                isIterationVariable(parent)
-            )
-        ) ||
-        isArgumentOfWellKnownMutationFunction(id, scope)
-    );
+	const { parent } = id;
+
+	return (
+		(parent.type === "MemberExpression" &&
+			parent.object === id &&
+			(isAssignmentLeft(parent) ||
+				isOperandOfMutationUnaryOperator(parent) ||
+				isIterationVariable(parent))) ||
+		isArgumentOfWellKnownMutationFunction(id, scope)
+	);
 }
 
 /**
@@ -153,89 +137,91 @@ function isMemberWrite(id, scope) {
  * @returns {ASTNode} The mutation node.
  */
 function getWriteNode(id) {
-    let node = id.parent;
-
-    while (
-        node &&
-        node.type !== "AssignmentExpression" &&
-        node.type !== "UpdateExpression" &&
-        node.type !== "UnaryExpression" &&
-        node.type !== "CallExpression" &&
-        node.type !== "ForInStatement" &&
-        node.type !== "ForOfStatement"
-    ) {
-        node = node.parent;
-    }
-
-    return node || id;
+	let node = id.parent;
+
+	while (
+		node &&
+		node.type !== "AssignmentExpression" &&
+		node.type !== "UpdateExpression" &&
+		node.type !== "UnaryExpression" &&
+		node.type !== "CallExpression" &&
+		node.type !== "ForInStatement" &&
+		node.type !== "ForOfStatement"
+	) {
+		node = node.parent;
+	}
+
+	return node || id;
 }
 
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
 
-/** @type {import('../shared/types').Rule} */
+/** @type {import('../types').Rule.RuleModule} */
 module.exports = {
-    meta: {
-        type: "problem",
-
-        docs: {
-            description: "Disallow assigning to imported bindings",
-            recommended: true,
-            url: "https://eslint.org/docs/latest/rules/no-import-assign"
-        },
-
-        schema: [],
-
-        messages: {
-            readonly: "'{{name}}' is read-only.",
-            readonlyMember: "The members of '{{name}}' are read-only."
-        }
-    },
-
-    create(context) {
-        const sourceCode = context.sourceCode;
-
-        return {
-            ImportDeclaration(node) {
-                const scope = sourceCode.getScope(node);
-
-                for (const variable of sourceCode.getDeclaredVariables(node)) {
-                    const shouldCheckMembers = variable.defs.some(
-                        d => d.node.type === "ImportNamespaceSpecifier"
-                    );
-                    let prevIdNode = null;
-
-                    for (const reference of variable.references) {
-                        const idNode = reference.identifier;
-
-                        /*
-                         * AssignmentPattern (e.g. `[a = 0] = b`) makes two write
-                         * references for the same identifier. This should skip
-                         * the one of the two in order to prevent redundant reports.
-                         */
-                        if (idNode === prevIdNode) {
-                            continue;
-                        }
-                        prevIdNode = idNode;
-
-                        if (reference.isWrite()) {
-                            context.report({
-                                node: getWriteNode(idNode),
-                                messageId: "readonly",
-                                data: { name: idNode.name }
-                            });
-                        } else if (shouldCheckMembers && isMemberWrite(idNode, scope)) {
-                            context.report({
-                                node: getWriteNode(idNode),
-                                messageId: "readonlyMember",
-                                data: { name: idNode.name }
-                            });
-                        }
-                    }
-                }
-            }
-        };
-
-    }
+	meta: {
+		type: "problem",
+
+		docs: {
+			description: "Disallow assigning to imported bindings",
+			recommended: true,
+			url: "https://eslint.org/docs/latest/rules/no-import-assign",
+		},
+
+		schema: [],
+
+		messages: {
+			readonly: "'{{name}}' is read-only.",
+			readonlyMember: "The members of '{{name}}' are read-only.",
+		},
+	},
+
+	create(context) {
+		const sourceCode = context.sourceCode;
+
+		return {
+			ImportDeclaration(node) {
+				const scope = sourceCode.getScope(node);
+
+				for (const variable of sourceCode.getDeclaredVariables(node)) {
+					const shouldCheckMembers = variable.defs.some(
+						d => d.node.type === "ImportNamespaceSpecifier",
+					);
+					let prevIdNode = null;
+
+					for (const reference of variable.references) {
+						const idNode = reference.identifier;
+
+						/*
+						 * AssignmentPattern (e.g. `[a = 0] = b`) makes two write
+						 * references for the same identifier. This should skip
+						 * the one of the two in order to prevent redundant reports.
+						 */
+						if (idNode === prevIdNode) {
+							continue;
+						}
+						prevIdNode = idNode;
+
+						if (reference.isWrite()) {
+							context.report({
+								node: getWriteNode(idNode),
+								messageId: "readonly",
+								data: { name: idNode.name },
+							});
+						} else if (
+							shouldCheckMembers &&
+							isMemberWrite(idNode, scope)
+						) {
+							context.report({
+								node: getWriteNode(idNode),
+								messageId: "readonlyMember",
+								data: { name: idNode.name },
+							});
+						}
+					}
+				}
+			},
+		};
+	},
 };

package/lib/rules/no-inline-comments.js

@@ -10,101 +10,106 @@ const astUtils = require("./utils/ast-utils");
 // Rule Definition
 //------------------------------------------------------------------------------
 
-/** @type {import('../shared/types').Rule} */
+/** @type {import('../types').Rule.RuleModule} */
 module.exports = {
-    meta: {
-        type: "suggestion",
-
-        docs: {
-            description: "Disallow inline comments after code",
-            recommended: false,
-            url: "https://eslint.org/docs/latest/rules/no-inline-comments"
-        },
-
-        schema: [
-            {
-                type: "object",
-                properties: {
-                    ignorePattern: {
-                        type: "string"
-                    }
-                },
-                additionalProperties: false
-            }
-        ],
-
-        messages: {
-            unexpectedInlineComment: "Unexpected comment inline with code."
-        }
-    },
-
-    create(context) {
-        const sourceCode = context.sourceCode;
-        const options = context.options[0];
-        let customIgnoreRegExp;
-
-        if (options && options.ignorePattern) {
-            customIgnoreRegExp = new RegExp(options.ignorePattern, "u");
-        }
-
-        /**
-         * Will check that comments are not on lines starting with or ending with code
-         * @param {ASTNode} node The comment node to check
-         * @private
-         * @returns {void}
-         */
-        function testCodeAroundComment(node) {
-
-            const startLine = String(sourceCode.lines[node.loc.start.line - 1]),
-                endLine = String(sourceCode.lines[node.loc.end.line - 1]),
-                preamble = startLine.slice(0, node.loc.start.column).trim(),
-                postamble = endLine.slice(node.loc.end.column).trim(),
-                isPreambleEmpty = !preamble,
-                isPostambleEmpty = !postamble;
-
-            // Nothing on both sides
-            if (isPreambleEmpty && isPostambleEmpty) {
-                return;
-            }
-
-            // Matches the ignore pattern
-            if (customIgnoreRegExp && customIgnoreRegExp.test(node.value)) {
-                return;
-            }
-
-            // JSX Exception
-            if (
-                (isPreambleEmpty || preamble === "{") &&
-                (isPostambleEmpty || postamble === "}")
-            ) {
-                const enclosingNode = sourceCode.getNodeByRangeIndex(node.range[0]);
-
-                if (enclosingNode && enclosingNode.type === "JSXEmptyExpression") {
-                    return;
-                }
-            }
-
-            // Don't report ESLint directive comments
-            if (astUtils.isDirectiveComment(node)) {
-                return;
-            }
-
-            context.report({
-                node,
-                messageId: "unexpectedInlineComment"
-            });
-        }
-
-        //--------------------------------------------------------------------------
-        // Public
-        //--------------------------------------------------------------------------
-
-        return {
-            Program() {
-                sourceCode.getAllComments()
-                    .filter(token => token.type !== "Shebang")
-                    .forEach(testCodeAroundComment);
-            }
-        };
-    }
+	meta: {
+		type: "suggestion",
+
+		defaultOptions: [{}],
+
+		docs: {
+			description: "Disallow inline comments after code",
+			recommended: false,
+			frozen: true,
+			url: "https://eslint.org/docs/latest/rules/no-inline-comments",
+		},
+
+		schema: [
+			{
+				type: "object",
+				properties: {
+					ignorePattern: {
+						type: "string",
+					},
+				},
+				additionalProperties: false,
+			},
+		],
+
+		messages: {
+			unexpectedInlineComment: "Unexpected comment inline with code.",
+		},
+	},
+
+	create(context) {
+		const sourceCode = context.sourceCode;
+		const [{ ignorePattern }] = context.options;
+		const customIgnoreRegExp =
+			ignorePattern && new RegExp(ignorePattern, "u");
+
+		/**
+		 * Will check that comments are not on lines starting with or ending with code
+		 * @param {ASTNode} node The comment node to check
+		 * @private
+		 * @returns {void}
+		 */
+		function testCodeAroundComment(node) {
+			const startLine = String(sourceCode.lines[node.loc.start.line - 1]),
+				endLine = String(sourceCode.lines[node.loc.end.line - 1]),
+				preamble = startLine.slice(0, node.loc.start.column).trim(),
+				postamble = endLine.slice(node.loc.end.column).trim(),
+				isPreambleEmpty = !preamble,
+				isPostambleEmpty = !postamble;
+
+			// Nothing on both sides
+			if (isPreambleEmpty && isPostambleEmpty) {
+				return;
+			}
+
+			// Matches the ignore pattern
+			if (customIgnoreRegExp && customIgnoreRegExp.test(node.value)) {
+				return;
+			}
+
+			// JSX Exception
+			if (
+				(isPreambleEmpty || preamble === "{") &&
+				(isPostambleEmpty || postamble === "}")
+			) {
+				const enclosingNode = sourceCode.getNodeByRangeIndex(
+					node.range[0],
+				);
+
+				if (
+					enclosingNode &&
+					enclosingNode.type === "JSXEmptyExpression"
+				) {
+					return;
+				}
+			}
+
+			// Don't report ESLint directive comments
+			if (astUtils.isDirectiveComment(node)) {
+				return;
+			}
+
+			context.report({
+				node,
+				messageId: "unexpectedInlineComment",
+			});
+		}
+
+		//--------------------------------------------------------------------------
+		// Public
+		//--------------------------------------------------------------------------
+
+		return {
+			Program() {
+				sourceCode
+					.getAllComments()
+					.filter(token => token.type !== "Shebang")
+					.forEach(testCodeAroundComment);
+			},
+		};
+	},
 };