--- /dev/null
+/**
+ * @fileoverview Rule to flag statements without curly braces
+ * @author Nicholas C. Zakas
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("./utils/ast-utils");
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = {
+ meta: {
+ type: "suggestion",
+
+ docs: {
+ description: "enforce consistent brace style for all control statements",
+ category: "Best Practices",
+ recommended: false,
+ url: "https://eslint.org/docs/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
+ }
+ ]
+ },
+
+ 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.getSourceCode();
+
+ //--------------------------------------------------------------------------
+ // 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 the given node is a lexical declaration (let, const, function, or class)
+ * @param {ASTNode} node The node to check
+ * @returns {boolean} True if the node is a lexical declaration
+ * @private
+ */
+ function isLexicalDeclaration(node) {
+ if (node.type === "VariableDeclaration") {
+ return node.kind === "const" || node.kind === "let";
+ }
+
+ return node.type === "FunctionDeclaration" || node.type === "ClassDeclaration";
+ }
+
+ /**
+ * Checks if the given token is an `else` token or not.
+ * @param {Token} token The token to check.
+ * @returns {boolean} `true` if the token is an `else` token.
+ */
+ function isElseKeywordToken(token) {
+ return token.value === "else" && token.type === "Keyword";
+ }
+
+ /**
+ * Gets the `else` keyword token of a given `IfStatement` node.
+ * @param {ASTNode} node A `IfStatement` node to get.
+ * @returns {Token} The `else` keyword token.
+ */
+ function getElseKeyword(node) {
+ return node.alternate && sourceCode.getFirstTokenBetween(node.consequent, node.alternate, isElseKeywordToken);
+ }
+
+ /**
+ * Checks a given IfStatement node requires braces of the consequent chunk.
+ * This returns `true` when below:
+ *
+ * 1. The given node has the `alternate` node.
+ * 2. There is a `IfStatement` which doesn't have `alternate` node in the
+ * trailing statement chain of the `consequent` node.
+ * @param {ASTNode} node A IfStatement node to check.
+ * @returns {boolean} `true` if the node requires braces of the consequent chunk.
+ */
+ function requiresBraceOfConsequent(node) {
+ if (node.alternate && node.consequent.type === "BlockStatement") {
+ if (node.consequent.body.length >= 2) {
+ return true;
+ }
+
+ for (
+ let currentNode = node.consequent.body[0];
+ currentNode;
+ currentNode = astUtils.getTrailingStatement(currentNode)
+ ) {
+ if (currentNode.type === "IfStatement" && !currentNode.alternate) {
+ return true;
+ }
+ }
+ }
+
+ return false;
+ }
+
+ /**
+ * 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 (node.type === "IfStatement" && node.consequent === body && requiresBraceOfConsequent(node)) {
+ expected = true;
+ } else if (multiOnly) {
+ if (hasBlock && body.body.length === 1 && !isLexicalDeclaration(body.body[0])) {
+ expected = false;
+ }
+ } else if (multiLine) {
+ if (!isCollapsedOneLiner(body)) {
+ expected = true;
+ }
+ } else if (multiOrNest) {
+ if (hasBlock && body.body.length === 1 && isOneLiner(body.body[0])) {
+ const leadingComments = sourceCode.getCommentsBefore(body.body[0]);
+ const isLexDef = isLexicalDeclaration(body.body[0]);
+
+ if (isLexDef) {
+ expected = true;
+ } else {
+ expected = leadingComments.length > 0;
+ }
+ } else if (!isOneLiner(body)) {
+ expected = true;
+ }
+ } else {
+ expected = true;
+ }
+
+ return {
+ actual: hasBlock,
+ expected,
+ check() {
+ if (this.expected !== null && this.expected !== this.actual) {
+ if (this.expected) {
+ context.report({
+ node,
+ loc: (name !== "else" ? node : getElseKeyword(node)).loc.start,
+ messageId: opts && opts.condition ? "missingCurlyAfterCondition" : "missingCurlyAfter",
+ data: {
+ name
+ },
+ fix: fixer => fixer.replaceText(body, `{${sourceCode.getText(body)}}`)
+ });
+ } else {
+ context.report({
+ node,
+ loc: (name !== "else" ? node : getElseKeyword(node)).loc.start,
+ 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) {
+ if (node.parent.type !== "IfStatement") {
+ prepareIfChecks(node).forEach(preparedCheck => {
+ preparedCheck.check();
+ });
+ }
+ },
+
+ 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();
+ }
+ };
+ }
+};
projects / dotfiles / .git / blobdiff