node_modules/eslint/lib/rules/curly.js - devtools/devtools-frontend.git - Git at Google

 /**
  * @fileoverview Rule to flag statements without curly braces
  * @author Nicholas C. Zakas
  */
 "use strict";

 //------------------------------------------------------------------------------
 // Requirements
 //------------------------------------------------------------------------------

 const astUtils = require("./utils/ast-utils");

 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------

 /** @type {import('../types').Rule.RuleModule} */
 module.exports = {
 	meta: {
 		type: "suggestion",

 		docs: {
 			description:
 				"Enforce consistent brace style for all control statements",
 			recommended: false,
 			frozen: true,
 			url: "https://eslint.org/docs/latest/rules/curly",
 		},

 		schema: {
 			anyOf: [
 				{
 					type: "array",
 					items: [
 						{
 							enum: ["all"],
 						},
 					],
 					minItems: 0,
 					maxItems: 1,
 				},
 				{
 					type: "array",
 					items: [
 						{
 							enum: ["multi", "multi-line", "multi-or-nest"],
 						},
 						{
 							enum: ["consistent"],
 						},
 					],
 					minItems: 0,
 					maxItems: 2,
 				},
 			],
 		},

 		defaultOptions: ["all"],

 		fixable: "code",

 		messages: {
 			missingCurlyAfter: "Expected { after '{{name}}'.",
 			missingCurlyAfterCondition:
 				"Expected { after '{{name}}' condition.",
 			unexpectedCurlyAfter: "Unnecessary { after '{{name}}'.",
 			unexpectedCurlyAfterCondition:
 				"Unnecessary { after '{{name}}' condition.",
 		},
 	},

 	create(context) {
 		const multiOnly = context.options[0] === "multi";
 		const multiLine = context.options[0] === "multi-line";
 		const multiOrNest = context.options[0] === "multi-or-nest";
 		const consistent = context.options[1] === "consistent";

 		const sourceCode = context.sourceCode;

 		//--------------------------------------------------------------------------
 		// Helpers
 		//--------------------------------------------------------------------------

 		/**
 		 * Determines if a given node is a one-liner that's on the same line as it's preceding code.
 		 * @param {ASTNode} node The node to check.
 		 * @returns {boolean} True if the node is a one-liner that's on the same line as it's preceding code.
 		 * @private
 		 */
 		function isCollapsedOneLiner(node) {
 			const before = sourceCode.getTokenBefore(node);
 			const last = sourceCode.getLastToken(node);
 			const lastExcludingSemicolon = astUtils.isSemicolonToken(last)
 				? sourceCode.getTokenBefore(last)
 				: last;

 			return (
 				before.loc.start.line === lastExcludingSemicolon.loc.end.line
 			);
 		}

 		/**
 		 * Determines if a given node is a one-liner.
 		 * @param {ASTNode} node The node to check.
 		 * @returns {boolean} True if the node is a one-liner.
 		 * @private
 		 */
 		function isOneLiner(node) {
 			if (node.type === "EmptyStatement") {
 				return true;
 			}

 			const first = sourceCode.getFirstToken(node);
 			const last = sourceCode.getLastToken(node);
 			const lastExcludingSemicolon = astUtils.isSemicolonToken(last)
 				? sourceCode.getTokenBefore(last)
 				: last;

 			return first.loc.start.line === lastExcludingSemicolon.loc.end.line;
 		}

 		/**
 		 * Determines if a semicolon needs to be inserted after removing a set of curly brackets, in order to avoid a SyntaxError.
 		 * @param {Token} closingBracket The } token
 		 * @returns {boolean} `true` if a semicolon needs to be inserted after the last statement in the block.
 		 */
 		function needsSemicolon(closingBracket) {
 			const tokenBefore = sourceCode.getTokenBefore(closingBracket);
 			const tokenAfter = sourceCode.getTokenAfter(closingBracket);
 			const lastBlockNode = sourceCode.getNodeByRangeIndex(
 				tokenBefore.range[0],
 			);

 			if (astUtils.isSemicolonToken(tokenBefore)) {
 				// If the last statement already has a semicolon, don't add another one.
 				return false;
 			}

 			if (!tokenAfter) {
 				// If there are no statements after this block, there is no need to add a semicolon.
 				return false;
 			}

 			if (
 				lastBlockNode.type === "BlockStatement" &&
 				lastBlockNode.parent.type !== "FunctionExpression" &&
 				lastBlockNode.parent.type !== "ArrowFunctionExpression"
 			) {
 				/*
 				 * If the last node surrounded by curly brackets is a BlockStatement (other than a FunctionExpression or an ArrowFunctionExpression),
 				 * don't insert a semicolon. Otherwise, the semicolon would be parsed as a separate statement, which would cause
 				 * a SyntaxError if it was followed by `else`.
 				 */
 				return false;
 			}

 			if (tokenBefore.loc.end.line === tokenAfter.loc.start.line) {
 				// If the next token is on the same line, insert a semicolon.
 				return true;
 			}

 			if (/^[([/`+-]/u.test(tokenAfter.value)) {
 				// If the next token starts with a character that would disrupt ASI, insert a semicolon.
 				return true;
 			}

 			if (
 				tokenBefore.type === "Punctuator" &&
 				(tokenBefore.value === "++" || tokenBefore.value === "--")
 			) {
 				// If the last token is ++ or --, insert a semicolon to avoid disrupting ASI.
 				return true;
 			}

 			// Otherwise, do not insert a semicolon.
 			return false;
 		}

 		/**
 		 * Prepares to check the body of a node to see if it's a block statement.
 		 * @param {ASTNode} node The node to report if there's a problem.
 		 * @param {ASTNode} body The body node to check for blocks.
 		 * @param {string} name The name to report if there's a problem.
 		 * @param {{ condition: boolean }} opts Options to pass to the report functions
 		 * @returns {Object} a prepared check object, with "actual", "expected", "check" properties.
 		 *   "actual" will be `true` or `false` whether the body is already a block statement.
 		 *   "expected" will be `true` or `false` if the body should be a block statement or not, or
 		 *   `null` if it doesn't matter, depending on the rule options. It can be modified to change
 		 *   the final behavior of "check".
 		 *   "check" will be a function reporting appropriate problems depending on the other
 		 *   properties.
 		 */
 		function prepareCheck(node, body, name, opts) {
 			const hasBlock = body.type === "BlockStatement";
 			let expected = null;

 			if (
 				hasBlock &&
 				(body.body.length !== 1 ||
 					astUtils.areBracesNecessary(body, sourceCode))
 			) {
 				expected = true;
 			} else if (multiOnly) {
 				expected = false;
 			} else if (multiLine) {
 				if (!isCollapsedOneLiner(body)) {
 					expected = true;
 				}

 				// otherwise, the body is allowed to have braces or not to have braces
 			} else if (multiOrNest) {
 				if (hasBlock) {
 					const statement = body.body[0];
 					const leadingCommentsInBlock =
 						sourceCode.getCommentsBefore(statement);

 					expected =
 						!isOneLiner(statement) ||
 						leadingCommentsInBlock.length > 0;
 				} else {
 					expected = !isOneLiner(body);
 				}
 			} else {
 				// default "all"
 				expected = true;
 			}

 			return {
 				actual: hasBlock,
 				expected,
 				check() {
 					if (
 						this.expected !== null &&
 						this.expected !== this.actual
 					) {
 						if (this.expected) {
 							context.report({
 								node,
 								loc: body.loc,
 								messageId:
 									opts && opts.condition
 										? "missingCurlyAfterCondition"
 										: "missingCurlyAfter",
 								data: {
 									name,
 								},
 								fix: fixer =>
 									fixer.replaceText(
 										body,
 										`{${sourceCode.getText(body)}}`,
 									),
 							});
 						} else {
 							context.report({
 								node,
 								loc: body.loc,
 								messageId:
 									opts && opts.condition
 										? "unexpectedCurlyAfterCondition"
 										: "unexpectedCurlyAfter",
 								data: {
 									name,
 								},
 								fix(fixer) {
 									/*
 									 * `do while` expressions sometimes need a space to be inserted after `do`.
 									 * e.g. `do{foo()} while (bar)` should be corrected to `do foo() while (bar)`
 									 */
 									const needsPrecedingSpace =
 										node.type === "DoWhileStatement" &&
 										sourceCode.getTokenBefore(body)
 											.range[1] === body.range[0] &&
 										!astUtils.canTokensBeAdjacent(
 											"do",
 											sourceCode.getFirstToken(body, {
 												skip: 1,
 											}),
 										);

 									const openingBracket =
 										sourceCode.getFirstToken(body);
 									const closingBracket =
 										sourceCode.getLastToken(body);
 									const lastTokenInBlock =
 										sourceCode.getTokenBefore(
 											closingBracket,
 										);

 									if (needsSemicolon(closingBracket)) {
 										/*
 										 * If removing braces would cause a SyntaxError due to multiple statements on the same line (or
 										 * change the semantics of the code due to ASI), don't perform a fix.
 										 */
 										return null;
 									}

 									const resultingBodyText =
 										sourceCode
 											.getText()
 											.slice(
 												openingBracket.range[1],
 												lastTokenInBlock.range[0],
 											) +
 										sourceCode.getText(lastTokenInBlock) +
 										sourceCode
 											.getText()
 											.slice(
 												lastTokenInBlock.range[1],
 												closingBracket.range[0],
 											);

 									return fixer.replaceText(
 										body,
 										(needsPrecedingSpace ? " " : "") +
 											resultingBodyText,
 									);
 								},
 							});
 						}
 					}
 				},
 			};
 		}

 		/**
 		 * Prepares to check the bodies of a "if", "else if" and "else" chain.
 		 * @param {ASTNode} node The first IfStatement node of the chain.
 		 * @returns {Object[]} prepared checks for each body of the chain. See `prepareCheck` for more
 		 *   information.
 		 */
 		function prepareIfChecks(node) {
 			const preparedChecks = [];

 			for (
 				let currentNode = node;
 				currentNode;
 				currentNode = currentNode.alternate
 			) {
 				preparedChecks.push(
 					prepareCheck(currentNode, currentNode.consequent, "if", {
 						condition: true,
 					}),
 				);
 				if (
 					currentNode.alternate &&
 					currentNode.alternate.type !== "IfStatement"
 				) {
 					preparedChecks.push(
 						prepareCheck(
 							currentNode,
 							currentNode.alternate,
 							"else",
 						),
 					);
 					break;
 				}
 			}

 			if (consistent) {
 				/*
 				 * If any node should have or already have braces, make sure they
 				 * all have braces.
 				 * If all nodes shouldn't have braces, make sure they don't.
 				 */
 				const expected = preparedChecks.some(preparedCheck => {
 					if (preparedCheck.expected !== null) {
 						return preparedCheck.expected;
 					}
 					return preparedCheck.actual;
 				});

 				preparedChecks.forEach(preparedCheck => {
 					preparedCheck.expected = expected;
 				});
 			}

 			return preparedChecks;
 		}

 		//--------------------------------------------------------------------------
 		// Public
 		//--------------------------------------------------------------------------

 		return {
 			IfStatement(node) {
 				const parent = node.parent;
 				const isElseIf =
 					parent.type === "IfStatement" && parent.alternate === node;

 				if (!isElseIf) {
 					// This is a top `if`, check the whole `if-else-if` chain
 					prepareIfChecks(node).forEach(preparedCheck => {
 						preparedCheck.check();
 					});
 				}

 				// Skip `else if`, it's already checked (when the top `if` was visited)
 			},

 			WhileStatement(node) {
 				prepareCheck(node, node.body, "while", {
 					condition: true,
 				}).check();
 			},

 			DoWhileStatement(node) {
 				prepareCheck(node, node.body, "do").check();
 			},

 			ForStatement(node) {
 				prepareCheck(node, node.body, "for", {
 					condition: true,
 				}).check();
 			},

 			ForInStatement(node) {
 				prepareCheck(node, node.body, "for-in").check();
 			},

 			ForOfStatement(node) {
 				prepareCheck(node, node.body, "for-of").check();
 			},
 		};
 	},
 };
	/**
	* @fileoverview Rule to flag statements without curly braces
	* @author Nicholas C. Zakas
	*/
	"use strict";

	//------------------------------------------------------------------------------
	// Requirements
	//------------------------------------------------------------------------------

	const astUtils = require("./utils/ast-utils");

	//------------------------------------------------------------------------------
	// Rule Definition
	//------------------------------------------------------------------------------

	/** @type {import('../types').Rule.RuleModule} */
	module.exports = {
	meta: {
	type: "suggestion",

	docs: {
	description:
	"Enforce consistent brace style for all control statements",
	recommended: false,
	frozen: true,
	url: "https://eslint.org/docs/latest/rules/curly",
	},

	schema: {
	anyOf: [
	{
	type: "array",
	items: [
	{
	enum: ["all"],
	},
	],
	minItems: 0,
	maxItems: 1,
	},
	{
	type: "array",
	items: [
	{
	enum: ["multi", "multi-line", "multi-or-nest"],
	},
	{
	enum: ["consistent"],
	},
	],
	minItems: 0,
	maxItems: 2,
	},
	],
	},

	defaultOptions: ["all"],

	fixable: "code",

	messages: {
	missingCurlyAfter: "Expected { after '{{name}}'.",
	missingCurlyAfterCondition:
	"Expected { after '{{name}}' condition.",
	unexpectedCurlyAfter: "Unnecessary { after '{{name}}'.",
	unexpectedCurlyAfterCondition:
	"Unnecessary { after '{{name}}' condition.",
	},
	},

	create(context) {
	const multiOnly = context.options[0] === "multi";
	const multiLine = context.options[0] === "multi-line";
	const multiOrNest = context.options[0] === "multi-or-nest";
	const consistent = context.options[1] === "consistent";

	const sourceCode = context.sourceCode;

	//--------------------------------------------------------------------------
	// Helpers
	//--------------------------------------------------------------------------

	/**
	* Determines if a given node is a one-liner that's on the same line as it's preceding code.
	* @param {ASTNode} node The node to check.
	* @returns {boolean} True if the node is a one-liner that's on the same line as it's preceding code.
	* @private
	*/
	function isCollapsedOneLiner(node) {
	const before = sourceCode.getTokenBefore(node);
	const last = sourceCode.getLastToken(node);
	const lastExcludingSemicolon = astUtils.isSemicolonToken(last)
	? sourceCode.getTokenBefore(last)
	: last;

	return (
	before.loc.start.line === lastExcludingSemicolon.loc.end.line
	);
	}

	/**
	* Determines if a given node is a one-liner.
	* @param {ASTNode} node The node to check.
	* @returns {boolean} True if the node is a one-liner.
	* @private
	*/
	function isOneLiner(node) {
	if (node.type === "EmptyStatement") {
	return true;
	}

	const first = sourceCode.getFirstToken(node);
	const last = sourceCode.getLastToken(node);
	const lastExcludingSemicolon = astUtils.isSemicolonToken(last)
	? sourceCode.getTokenBefore(last)
	: last;

	return first.loc.start.line === lastExcludingSemicolon.loc.end.line;
	}

	/**
	* Determines if a semicolon needs to be inserted after removing a set of curly brackets, in order to avoid a SyntaxError.
	* @param {Token} closingBracket The } token
	* @returns {boolean} `true` if a semicolon needs to be inserted after the last statement in the block.
	*/
	function needsSemicolon(closingBracket) {
	const tokenBefore = sourceCode.getTokenBefore(closingBracket);
	const tokenAfter = sourceCode.getTokenAfter(closingBracket);
	const lastBlockNode = sourceCode.getNodeByRangeIndex(
	tokenBefore.range[0],
	);

	if (astUtils.isSemicolonToken(tokenBefore)) {
	// If the last statement already has a semicolon, don't add another one.
	return false;
	}

	if (!tokenAfter) {
	// If there are no statements after this block, there is no need to add a semicolon.
	return false;
	}

	if (
	lastBlockNode.type === "BlockStatement" &&
	lastBlockNode.parent.type !== "FunctionExpression" &&
	lastBlockNode.parent.type !== "ArrowFunctionExpression"
	) {
	/*
	* If the last node surrounded by curly brackets is a BlockStatement (other than a FunctionExpression or an ArrowFunctionExpression),
	* don't insert a semicolon. Otherwise, the semicolon would be parsed as a separate statement, which would cause
	* a SyntaxError if it was followed by `else`.
	*/
	return false;
	}

	if (tokenBefore.loc.end.line === tokenAfter.loc.start.line) {
	// If the next token is on the same line, insert a semicolon.
	return true;
	}

	if (/^[([/`+-]/u.test(tokenAfter.value)) {
	// If the next token starts with a character that would disrupt ASI, insert a semicolon.
	return true;
	}

	if (
	tokenBefore.type === "Punctuator" &&
	(tokenBefore.value === "++" \|\| tokenBefore.value === "--")
	) {
	// If the last token is ++ or --, insert a semicolon to avoid disrupting ASI.
	return true;
	}

	// Otherwise, do not insert a semicolon.
	return false;
	}

	/**
	* Prepares to check the body of a node to see if it's a block statement.
	* @param {ASTNode} node The node to report if there's a problem.
	* @param {ASTNode} body The body node to check for blocks.
	* @param {string} name The name to report if there's a problem.
	* @param {{ condition: boolean }} opts Options to pass to the report functions
	* @returns {Object} a prepared check object, with "actual", "expected", "check" properties.
	* "actual" will be `true` or `false` whether the body is already a block statement.
	* "expected" will be `true` or `false` if the body should be a block statement or not, or
	* `null` if it doesn't matter, depending on the rule options. It can be modified to change
	* the final behavior of "check".
	* "check" will be a function reporting appropriate problems depending on the other
	* properties.
	*/
	function prepareCheck(node, body, name, opts) {
	const hasBlock = body.type === "BlockStatement";
	let expected = null;

	if (
	hasBlock &&
	(body.body.length !== 1 \|\|
	astUtils.areBracesNecessary(body, sourceCode))
	) {
	expected = true;
	} else if (multiOnly) {
	expected = false;
	} else if (multiLine) {
	if (!isCollapsedOneLiner(body)) {
	expected = true;
	}

	// otherwise, the body is allowed to have braces or not to have braces
	} else if (multiOrNest) {
	if (hasBlock) {
	const statement = body.body[0];
	const leadingCommentsInBlock =
	sourceCode.getCommentsBefore(statement);

	expected =
	!isOneLiner(statement) \|\|
	leadingCommentsInBlock.length > 0;
	} else {
	expected = !isOneLiner(body);
	}
	} else {
	// default "all"
	expected = true;
	}

	return {
	actual: hasBlock,
	expected,
	check() {
	if (
	this.expected !== null &&
	this.expected !== this.actual
	) {
	if (this.expected) {
	context.report({
	node,
	loc: body.loc,
	messageId:
	opts && opts.condition
	? "missingCurlyAfterCondition"
	: "missingCurlyAfter",
	data: {
	name,
	},
	fix: fixer =>
	fixer.replaceText(
	body,
	`{${sourceCode.getText(body)}}`,
	),
	});
	} else {
	context.report({
	node,
	loc: body.loc,
	messageId:
	opts && opts.condition
	? "unexpectedCurlyAfterCondition"
	: "unexpectedCurlyAfter",
	data: {
	name,
	},
	fix(fixer) {
	/*
	* `do while` expressions sometimes need a space to be inserted after `do`.
	* e.g. `do{foo()} while (bar)` should be corrected to `do foo() while (bar)`
	*/
	const needsPrecedingSpace =
	node.type === "DoWhileStatement" &&
	sourceCode.getTokenBefore(body)
	.range[1] === body.range[0] &&
	!astUtils.canTokensBeAdjacent(
	"do",
	sourceCode.getFirstToken(body, {
	skip: 1,
	}),
	);

	const openingBracket =
	sourceCode.getFirstToken(body);
	const closingBracket =
	sourceCode.getLastToken(body);
	const lastTokenInBlock =
	sourceCode.getTokenBefore(
	closingBracket,
	);

	if (needsSemicolon(closingBracket)) {
	/*
	* If removing braces would cause a SyntaxError due to multiple statements on the same line (or
	* change the semantics of the code due to ASI), don't perform a fix.
	*/
	return null;
	}

	const resultingBodyText =
	sourceCode
	.getText()
	.slice(
	openingBracket.range[1],
	lastTokenInBlock.range[0],
	) +
	sourceCode.getText(lastTokenInBlock) +
	sourceCode
	.getText()
	.slice(
	lastTokenInBlock.range[1],
	closingBracket.range[0],
	);

	return fixer.replaceText(
	body,
	(needsPrecedingSpace ? " " : "") +
	resultingBodyText,
	);
	},
	});
	}
	}
	},
	};
	}

	/**
	* Prepares to check the bodies of a "if", "else if" and "else" chain.
	* @param {ASTNode} node The first IfStatement node of the chain.
	* @returns {Object[]} prepared checks for each body of the chain. See `prepareCheck` for more
	* information.
	*/
	function prepareIfChecks(node) {
	const preparedChecks = [];

	for (
	let currentNode = node;
	currentNode;
	currentNode = currentNode.alternate
	) {
	preparedChecks.push(
	prepareCheck(currentNode, currentNode.consequent, "if", {
	condition: true,
	}),
	);
	if (
	currentNode.alternate &&
	currentNode.alternate.type !== "IfStatement"
	) {
	preparedChecks.push(
	prepareCheck(
	currentNode,
	currentNode.alternate,
	"else",
	),
	);
	break;
	}
	}

	if (consistent) {
	/*
	* If any node should have or already have braces, make sure they
	* all have braces.
	* If all nodes shouldn't have braces, make sure they don't.
	*/
	const expected = preparedChecks.some(preparedCheck => {
	if (preparedCheck.expected !== null) {
	return preparedCheck.expected;
	}
	return preparedCheck.actual;
	});

	preparedChecks.forEach(preparedCheck => {
	preparedCheck.expected = expected;
	});
	}

	return preparedChecks;
	}

	//--------------------------------------------------------------------------
	// Public
	//--------------------------------------------------------------------------

	return {
	IfStatement(node) {
	const parent = node.parent;
	const isElseIf =
	parent.type === "IfStatement" && parent.alternate === node;

	if (!isElseIf) {
	// This is a top `if`, check the whole `if-else-if` chain
	prepareIfChecks(node).forEach(preparedCheck => {
	preparedCheck.check();
	});
	}

	// Skip `else if`, it's already checked (when the top `if` was visited)
	},

	WhileStatement(node) {
	prepareCheck(node, node.body, "while", {
	condition: true,
	}).check();
	},

	DoWhileStatement(node) {
	prepareCheck(node, node.body, "do").check();
	},

	ForStatement(node) {
	prepareCheck(node, node.body, "for", {
	condition: true,
	}).check();
	},

	ForInStatement(node) {
	prepareCheck(node, node.body, "for-in").check();
	},

	ForOfStatement(node) {
	prepareCheck(node, node.body, "for-of").check();
	},
	};
	},
	};