eslint 3.13.1 → 3.16.0

package/lib/rules/no-else-return.js

@@ -17,7 +17,9 @@ module.exports = {
             recommended: false
         },
 
-        schema: []
+        schema: [],
+
+        fixable: "code"
     },
 
     create(context) {
@@ -33,7 +35,60 @@ module.exports = {
          * @returns {void}
          */
         function displayReport(node) {
-            context.report({ node, message: "Unnecessary 'else' after 'return'." });
+            context.report({
+                node,
+                message: "Unnecessary 'else' after 'return'.",
+                fix: fixer => {
+                    const sourceCode = context.getSourceCode();
+                    const startToken = sourceCode.getFirstToken(node);
+                    const elseToken = sourceCode.getTokenBefore(startToken);
+                    const source = sourceCode.getText(node);
+                    const lastIfToken = sourceCode.getTokenBefore(elseToken);
+                    let fixedSource, firstTokenOfElseBlock;
+
+                    if (startToken.type === "Punctuator" && startToken.value === "{") {
+                        firstTokenOfElseBlock = sourceCode.getTokenAfter(startToken);
+                    } else {
+                        firstTokenOfElseBlock = startToken;
+                    }
+
+                    // If the if block does not have curly braces and does not end in a semicolon
+                    // and the else block starts with (, [, /, +, ` or -, then it is not
+                    // safe to remove the else keyword, because ASI will not add a semicolon
+                    // after the if block
+                    const ifBlockMaybeUnsafe = node.parent.consequent.type !== "BlockStatement" && lastIfToken.value !== ";";
+                    const elseBlockUnsafe = /^[([/+`-]/.test(firstTokenOfElseBlock.value);
+
+                    if (ifBlockMaybeUnsafe && elseBlockUnsafe) {
+                        return null;
+                    }
+
+                    const endToken = sourceCode.getLastToken(node);
+                    const lastTokenOfElseBlock = sourceCode.getTokenBefore(endToken);
+
+                    if (lastTokenOfElseBlock.value !== ";") {
+                        const nextToken = sourceCode.getTokenAfter(endToken);
+
+                        const nextTokenUnsafe = nextToken && /^[([/+`-]/.test(nextToken.value);
+                        const nextTokenOnSameLine = nextToken && nextToken.loc.start.line === lastTokenOfElseBlock.loc.start.line;
+
+                        // If the else block contents does not end in a semicolon,
+                        // and the else block starts with (, [, /, +, ` or -, then it is not
+                        // safe to remove the else block, because ASI will not add a semicolon
+                        // after the remaining else block contents
+                        if (nextTokenUnsafe || (nextTokenOnSameLine && nextToken.value !== "}")) {
+                            return null;
+                        }
+                    }
+
+                    if (startToken.type === "Punctuator" && startToken.value === "{") {
+                        fixedSource = source.slice(1, -1);
+                    } else {
+                        fixedSource = source;
+                    }
+                    return fixer.replaceTextRange([elseToken.start, node.end], fixedSource);
+                }
+            });
         }
 
         /**
@@ -121,35 +176,43 @@ module.exports = {
             return checkForReturnOrIf(node);
         }
 
+        /**
+         * Check the if statement
+         * @returns {void}
+         * @param {Node} node The node for the if statement to check
+         * @private
+         */
+        function IfStatement(node) {
+            const parent = context.getAncestors().pop();
+            let consequents,
+                alternate;
+
+            // Only "top-level" if statements are checked, meaning the first `if`
+            // in a `if-else-if-...` chain.
+            if (parent.type === "IfStatement" && parent.alternate === node) {
+                return;
+            }
+
+            for (consequents = []; node.type === "IfStatement"; node = node.alternate) {
+                if (!node.alternate) {
+                    return;
+                }
+                consequents.push(node.consequent);
+                alternate = node.alternate;
+            }
+
+            if (consequents.every(alwaysReturns)) {
+                displayReport(alternate);
+            }
+        }
+
         //--------------------------------------------------------------------------
         // Public API
         //--------------------------------------------------------------------------
 
         return {
 
-            IfStatement(node) {
-                const parent = context.getAncestors().pop();
-                let consequents,
-                    alternate;
-
-                // Only "top-level" if statements are checked, meaning the first `if`
-                // in a `if-else-if-...` chain.
-                if (parent.type === "IfStatement" && parent.alternate === node) {
-                    return;
-                }
-
-                for (consequents = []; node.type === "IfStatement"; node = node.alternate) {
-                    if (!node.alternate) {
-                        return;
-                    }
-                    consequents.push(node.consequent);
-                    alternate = node.alternate;
-                }
-
-                if (consequents.every(alwaysReturns)) {
-                    displayReport(alternate);
-                }
-            }
+            "IfStatement:exit": IfStatement
 
         };
 

package/lib/rules/no-extend-native.js

@@ -60,9 +60,9 @@ module.exports = {
                     return;
                 }
 
-                const affectsProto = lhs.object.computed ?
-                    lhs.object.property.type === "Literal" && lhs.object.property.value === "prototype" :
-                    lhs.object.property.name === "prototype";
+                const affectsProto = lhs.object.computed
+                    ? lhs.object.property.type === "Literal" && lhs.object.property.value === "prototype"
+                    : lhs.object.property.name === "prototype";
 
                 if (!affectsProto) {
                     return;

package/lib/rules/no-extra-bind.js

@@ -8,7 +8,7 @@
 // Requirements
 //------------------------------------------------------------------------------
 
-const getPropertyName = require("../ast-utils").getStaticPropertyName;
+const astUtils = require("../ast-utils");
 
 //------------------------------------------------------------------------------
 // Rule Definition
@@ -44,8 +44,7 @@ module.exports = {
                 loc: node.parent.property.loc.start,
                 fix(fixer) {
                     const firstTokenToRemove = context.getSourceCode()
-                        .getTokensBetween(node.parent.object, node.parent.property)
-                        .find(token => token.value !== ")");
+                        .getFirstTokenBetween(node.parent.object, node.parent.property, astUtils.isNotClosingParenToken);
 
                     return fixer.removeRange([firstTokenToRemove.range[0], node.parent.parent.range[1]]);
                 }
@@ -73,7 +72,7 @@ module.exports = {
                 grandparent.arguments.length === 1 &&
                 parent.type === "MemberExpression" &&
                 parent.object === node &&
-                getPropertyName(parent) === "bind"
+                astUtils.getStaticPropertyName(parent) === "bind"
             );
         }
 

package/lib/rules/no-extra-boolean-cast.js

@@ -5,6 +5,12 @@
 
 "use strict";
 
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("../ast-utils");
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -91,7 +97,22 @@ module.exports = {
                     context.report({
                         node,
                         message: "Redundant Boolean call.",
-                        fix: fixer => fixer.replaceText(node, sourceCode.getText(node.arguments[0]))
+                        fix: fixer => {
+                            if (!node.arguments.length) {
+                                return fixer.replaceText(parent, "true");
+                            }
+
+                            if (node.arguments.length > 1 || node.arguments[0].type === "SpreadElement") {
+                                return null;
+                            }
+
+                            const argument = node.arguments[0];
+
+                            if (astUtils.getPrecedence(argument) < astUtils.getPrecedence(node.parent)) {
+                                return fixer.replaceText(node, `(${sourceCode.getText(argument)})`);
+                            }
+                            return fixer.replaceText(node, sourceCode.getText(argument));
+                        }
                     });
                 }
             }

package/lib/rules/no-extra-parens.js

@@ -44,7 +44,8 @@ module.exports = {
                             properties: {
                                 conditionalAssign: { type: "boolean" },
                                 nestedBinaryExpressions: { type: "boolean" },
-                                returnAssign: { type: "boolean" }
+                                returnAssign: { type: "boolean" },
+                                ignoreJSX: { enum: ["none", "all", "single-line", "multi-line"] }
                             },
                             additionalProperties: false
                         }
@@ -65,6 +66,7 @@ module.exports = {
         const EXCEPT_COND_ASSIGN = ALL_NODES && context.options[1] && context.options[1].conditionalAssign === false;
         const NESTED_BINARY = ALL_NODES && context.options[1] && context.options[1].nestedBinaryExpressions === false;
         const EXCEPT_RETURN_ASSIGN = ALL_NODES && context.options[1] && context.options[1].returnAssign === false;
+        const IGNORE_JSX = ALL_NODES && context.options[1] && context.options[1].ignoreJSX;
 
         /**
          * Determines if this rule should be enforced for a node given the current configuration.
@@ -73,6 +75,31 @@ module.exports = {
          * @private
          */
         function ruleApplies(node) {
+            if (node.type === "JSXElement") {
+                const isSingleLine = node.loc.start.line === node.loc.end.line;
+
+                switch (IGNORE_JSX) {
+
+                    // Exclude this JSX element from linting
+                    case "all":
+                        return false;
+
+                    // Exclude this JSX element if it is multi-line element
+                    case "multi-line":
+                        return isSingleLine;
+
+                    // Exclude this JSX element if it is single-line element
+                    case "single-line":
+                        return !isSingleLine;
+
+                    // Nothing special to be done for JSX elements
+                    case "none":
+                        break;
+
+                    // no default
+                }
+            }
+
             return ALL_NODES || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression";
         }
 
@@ -140,6 +167,19 @@ module.exports = {
             return false;
         }
 
+        /**
+         * Determines if a constructor function is newed-up with parens
+         * @param {ASTNode} newExpression - The NewExpression node to be checked.
+         * @returns {boolean} True if the constructor is called with parens.
+         * @private
+         */
+        function isNewExpressionWithParens(newExpression) {
+            const lastToken = sourceCode.getLastToken(newExpression);
+            const penultimateToken = sourceCode.getTokenBefore(lastToken);
+
+            return newExpression.arguments.length > 0 || penultimateToken.value === "(" && lastToken.value === ")";
+        }
+
         /**
          * Determines if a node is or contains an assignment expression
          * @param {ASTNode} node - The node to be checked.
@@ -175,9 +215,9 @@ module.exports = {
                 return node.argument && containsAssignment(node.argument);
             } else if (node.type === "ArrowFunctionExpression" && node.body.type !== "BlockStatement") {
                 return containsAssignment(node.body);
-            } else {
-                return containsAssignment(node);
             }
+            return containsAssignment(node);
+
         }
 
         /**
@@ -326,6 +366,10 @@ module.exports = {
          * @private
          */
         function dryUnaryUpdate(node) {
+            if (node.type === "UnaryExpression" && node.argument.type === "BinaryExpression" && node.argument.operator === "**") {
+                return;
+            }
+
             if (hasExcessParens(node.argument) && precedence(node.argument) >= precedence(node)) {
                 report(node.argument);
             }
@@ -340,7 +384,8 @@ module.exports = {
         function dryCallNew(node) {
             if (hasExcessParens(node.callee) && precedence(node.callee) >= precedence(node) && !(
                 node.type === "CallExpression" &&
-                node.callee.type === "FunctionExpression" &&
+                (node.callee.type === "FunctionExpression" ||
+                  node.callee.type === "NewExpression" && !isNewExpressionWithParens(node.callee)) &&
 
                 // One set of parentheses are allowed for a function expression
                 !hasDoubleExcessParens(node.callee)
@@ -368,13 +413,17 @@ module.exports = {
          */
         function dryBinaryLogical(node) {
             const prec = precedence(node);
-            const shouldSkipLeft = NESTED_BINARY && (node.left.type === "BinaryExpression" || node.left.type === "LogicalExpression");
+            const leftPrecedence = precedence(node.left);
+            const rightPrecedence = precedence(node.right);
+            const isExponentiation = node.operator === "**";
+            const shouldSkipLeft = (NESTED_BINARY && (node.left.type === "BinaryExpression" || node.left.type === "LogicalExpression")) ||
+              node.left.type === "UnaryExpression" && isExponentiation;
             const shouldSkipRight = NESTED_BINARY && (node.right.type === "BinaryExpression" || node.right.type === "LogicalExpression");
 
-            if (!shouldSkipLeft && hasExcessParens(node.left) && precedence(node.left) >= prec) {
+            if (!shouldSkipLeft && hasExcessParens(node.left) && (leftPrecedence > prec || (leftPrecedence === prec && !isExponentiation))) {
                 report(node.left);
             }
-            if (!shouldSkipRight && hasExcessParens(node.right) && precedence(node.right) > prec) {
+            if (!shouldSkipRight && hasExcessParens(node.right) && (rightPrecedence > prec || (rightPrecedence === prec && isExponentiation))) {
                 report(node.right);
             }
         }
@@ -508,8 +557,7 @@ module.exports = {
                         !(
                             (node.object.type === "Literal" &&
                             typeof node.object.value === "number" &&
-                            astUtils.isDecimalInteger(node.object))
-                            ||
+                            astUtils.isDecimalInteger(node.object)) ||
 
                             // RegExp literal is allowed to have parens (#1589)
                             (node.object.type === "Literal" && node.object.regex)

package/lib/rules/no-inner-declarations.js

@@ -64,10 +64,10 @@ module.exports = {
 
             if (!valid) {
                 context.report({ node, message: "Move {{type}} declaration to {{body}} root.", data: {
-                    type: (node.type === "FunctionDeclaration" ?
-                            "function" : "variable"),
-                    body: (body.type === "Program" ?
-                            "program" : "function body")
+                    type: (node.type === "FunctionDeclaration"
+                            ? "function" : "variable"),
+                    body: (body.type === "Program"
+                            ? "program" : "function body")
                 } });
             }
         }

package/lib/rules/no-irregular-whitespace.js

@@ -6,6 +6,12 @@
 
 "use strict";
 
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("../ast-utils");
+
 //------------------------------------------------------------------------------
 // Constants
 //------------------------------------------------------------------------------
@@ -13,7 +19,7 @@
 const ALL_IRREGULARS = /[\f\v\u0085\u00A0\ufeff\u00a0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u200b\u202f\u205f\u3000\u2028\u2029]/;
 const IRREGULAR_WHITESPACE = /[\f\v\u0085\u00A0\ufeff\u00a0\u1680\u180e\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u200b\u202f\u205f\u3000]+/mg;
 const IRREGULAR_LINE_TERMINATORS = /[\u2028\u2029]/mg;
-const LINE_BREAK = /\r\n|\r|\n|\u2028|\u2029/g;
+const LINE_BREAK = astUtils.createGlobalLinebreakMatcher();
 
 //------------------------------------------------------------------------------
 // Rule Definition

package/lib/rules/no-lone-blocks.js

@@ -32,22 +32,22 @@ module.exports = {
          * @returns {void}
         */
         function report(node) {
-            const parent = context.getAncestors().pop();
+            const message = node.parent.type === "BlockStatement" ? "Nested block is redundant." : "Block is redundant.";
 
-            context.report({ node, message: parent.type === "Program" ?
-                "Block is redundant." :
-                "Nested block is redundant."
-            });
+            context.report({ node, message });
         }
 
         /**
-         * Checks for any ocurrence of BlockStatement > BlockStatement or Program > BlockStatement
-         * @returns {boolean} True if the current node is a lone block.
+         * Checks for any ocurrence of a BlockStatement in a place where lists of statements can appear
+         * @param {ASTNode} node The node to check
+         * @returns {boolean} True if the node is a lone block.
         */
-        function isLoneBlock() {
-            const parent = context.getAncestors().pop();
+        function isLoneBlock(node) {
+            return node.parent.type === "BlockStatement" ||
+                node.parent.type === "Program" ||
 
-            return parent.type === "BlockStatement" || parent.type === "Program";
+                // Don't report blocks in switch cases if the block is the only statement of the case.
+                node.parent.type === "SwitchCase" && !(node.parent.consequent[0] === node && node.parent.consequent.length === 1);
         }
 
         /**

package/lib/rules/no-mixed-operators.js

@@ -148,13 +148,7 @@ module.exports = {
          * @returns {Token} The operator token of the node.
          */
         function getOperatorToken(node) {
-            let token = sourceCode.getTokenAfter(node.left);
-
-            while (token.value === ")") {
-                token = sourceCode.getTokenAfter(token);
-            }
-
-            return token;
+            return sourceCode.getTokenAfter(node.left, astUtils.isNotClosingParenToken);
         }
 
         /**

package/lib/rules/no-mixed-requires.js

@@ -153,11 +153,11 @@ module.exports = {
 
                 // "var utils = require('./utils');"
                 return REQ_FILE;
-            } else {
-
-                // "var async = require('async');"
-                return REQ_MODULE;
             }
+
+            // "var async = require('async');"
+            return REQ_MODULE;
+
         }
 
         /**

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

@@ -0,0 +1,41 @@
+/**
+ * @fileoverview Rule to check use of chained assignment expressions
+ * @author Stewart Rand
+ */
+
+"use strict";
+
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = {
+    meta: {
+        docs: {
+            description: "disallow use of chained assignment expressions",
+            category: "Stylistic Issues",
+            recommended: false
+        },
+        schema: []
+    },
+
+    create(context) {
+
+        //--------------------------------------------------------------------------
+        // Public
+        //--------------------------------------------------------------------------
+
+        return {
+            AssignmentExpression(node) {
+                if (["AssignmentExpression", "VariableDeclarator"].indexOf(node.parent.type) !== -1) {
+                    context.report({
+                        node,
+                        message: "Unexpected chained assignment."
+                    });
+                }
+            }
+        };
+
+    }
+};

package/lib/rules/no-multi-spaces.js

@@ -5,6 +5,8 @@
 
 "use strict";
 
+const astUtils = require("../ast-utils");
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -93,7 +95,8 @@ module.exports = {
                 const sourceCode = context.getSourceCode(),
                     source = sourceCode.getText(),
                     allComments = sourceCode.getAllComments(),
-                    pattern = /[^\n\r\u2028\u2029\t ].? {2,}/g;  // note: repeating space
+                    JOINED_LINEBEAKS = Array.from(astUtils.LINEBREAKS).join(""),
+                    pattern = new RegExp(String.raw`[^ \t${JOINED_LINEBEAKS}].? {2,}`, "g");  // note: repeating space
                 let parent;
 
 

package/lib/rules/no-multi-str.js

@@ -5,6 +5,12 @@
 
 "use strict";
 
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("../ast-utils");
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -39,9 +45,7 @@ module.exports = {
         return {
 
             Literal(node) {
-                const lineBreak = /\n/;
-
-                if (lineBreak.test(node.raw) && !isJSXElement(node.parent)) {
+                if (astUtils.LINEBREAK_MATCHER.test(node.raw) && !isJSXElement(node.parent)) {
                     context.report({ node, message: "Multiline support is limited to browsers supporting ES5 only." });
                 }
             }

package/lib/rules/no-redeclare.js

@@ -89,13 +89,13 @@ module.exports = {
                 BlockStatement: checkForBlock,
                 SwitchStatement: checkForBlock
             };
-        } else {
-            return {
-                Program: checkForGlobal,
-                FunctionDeclaration: checkForBlock,
-                FunctionExpression: checkForBlock,
-                ArrowFunctionExpression: checkForBlock
-            };
         }
+        return {
+            Program: checkForGlobal,
+            FunctionDeclaration: checkForBlock,
+            FunctionExpression: checkForBlock,
+            ArrowFunctionExpression: checkForBlock
+        };
+
     }
 };

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

@@ -5,23 +5,16 @@
 "use strict";
 
 //------------------------------------------------------------------------------
-// Helpers
+// Requirements
 //------------------------------------------------------------------------------
 
-const SENTINEL_TYPE = /^(?:[a-zA-Z]+?Statement|ArrowFunctionExpression|FunctionExpression|ClassExpression)$/;
+const astUtils = require("../ast-utils");
 
-/**
- * Checks whether or not a node is enclosed in parentheses.
- * @param {Node|null} node - A node to check.
- * @param {sourceCode} sourceCode - The ESLint SourceCode object.
- * @returns {boolean} Whether or not the node is enclosed in parentheses.
- */
-function isEnclosedInParens(node, sourceCode) {
-    const prevToken = sourceCode.getTokenBefore(node);
-    const nextToken = sourceCode.getTokenAfter(node);
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
 
-    return prevToken && prevToken.value === "(" && nextToken && nextToken.value === ")";
-}
+const SENTINEL_TYPE = /^(?:[a-zA-Z]+?Statement|ArrowFunctionExpression|FunctionExpression|ClassExpression)$/;
 
 //------------------------------------------------------------------------------
 // Rule Definition
@@ -48,7 +41,7 @@ module.exports = {
 
         return {
             AssignmentExpression(node) {
-                if (!always && isEnclosedInParens(node, sourceCode)) {
+                if (!always && astUtils.isParenthesised(sourceCode, node)) {
                     return;
                 }
 

package/lib/rules/no-return-await.js

@@ -35,7 +35,7 @@ module.exports = {
             context.report({
                 node: context.getSourceCode().getFirstToken(node),
                 loc: node.loc,
-                message,
+                message
             });
         }
 
@@ -88,7 +88,7 @@ module.exports = {
                 if (isInTailCallPosition(node) && !hasErrorHandler(node)) {
                     reportUnnecessaryAwait(node);
                 }
-            },
+            }
         };
     }
 };

package/lib/rules/no-sequences.js

@@ -5,6 +5,12 @@
 
 "use strict";
 
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("../ast-utils");
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -57,12 +63,7 @@ module.exports = {
          * @returns {boolean} True if the node has a paren on each side.
          */
         function isParenthesised(node) {
-            const previousToken = sourceCode.getTokenBefore(node),
-                nextToken = sourceCode.getTokenAfter(node);
-
-            return previousToken && nextToken &&
-                previousToken.value === "(" && previousToken.range[1] <= node.range[0] &&
-                nextToken.value === ")" && nextToken.range[0] >= node.range[1];
+            return astUtils.isParenthesised(sourceCode, node);
         }
 
         /**