eslint 3.15.0 → 3.16.0

package/lib/rules/newline-per-chained-call.js

@@ -6,6 +6,8 @@
 
 "use strict";
 
+const astUtils = require("../ast-utils");
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -47,7 +49,7 @@ module.exports = {
          */
         function getPropertyText(node) {
             const prefix = node.computed ? "[" : ".";
-            const lines = sourceCode.getText(node.property).split(/\r\n|\r|\n/g);
+            const lines = sourceCode.getText(node.property).split(astUtils.LINEBREAK_MATCHER);
             const suffix = node.computed && lines.length === 1 ? "]" : "";
 
             return prefix + lines[0] + suffix;

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

@@ -101,9 +101,9 @@ module.exports = {
         function testForAssign(node) {
             if (node.test &&
                 (node.test.type === "AssignmentExpression") &&
-                (node.type === "ForStatement" ?
-                    !isParenthesised(node.test) :
-                    !isParenthesisedTwice(node.test)
+                (node.type === "ForStatement"
+                    ? !isParenthesised(node.test)
+                    : !isParenthesisedTwice(node.test)
                 )
             ) {
 

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

@@ -98,6 +98,14 @@ module.exports = {
                         node,
                         message: "Redundant Boolean call.",
                         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)) {

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

@@ -557,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-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-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-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);
         }
 
         /**

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

@@ -4,6 +4,12 @@
  */
 "use strict";
 
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("../ast-utils");
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -34,7 +40,7 @@ module.exports = {
     create(context) {
         const sourceCode = context.getSourceCode();
 
-        const BLANK_CLASS = "[ \t\u00a0\u2000-\u200b\u2028\u2029\u3000]",
+        const BLANK_CLASS = "[ \t\u00a0\u2000-\u200b\u3000]",
             SKIP_BLANK = `^${BLANK_CLASS}*$`,
             NONBLANK = `${BLANK_CLASS}+$`;
 
@@ -81,7 +87,7 @@ module.exports = {
                 const re = new RegExp(NONBLANK),
                     skipMatch = new RegExp(SKIP_BLANK),
                     lines = sourceCode.lines,
-                    linebreaks = sourceCode.getText().match(/\r\n|\r|\n|\u2028|\u2029/g);
+                    linebreaks = sourceCode.getText().match(astUtils.createGlobalLinebreakMatcher());
                 let totalLength = 0,
                     fixRange = [];
 

package/lib/rules/no-undefined.js

@@ -21,15 +21,54 @@ module.exports = {
 
     create(context) {
 
+        /**
+         * Report an invalid "undefined" identifier node.
+         * @param {ASTNode} node The node to report.
+         * @returns {void}
+         */
+        function report(node) {
+            context.report({
+                node,
+                message: "Unexpected use of undefined."
+            });
+        }
+
+        /**
+         * Checks the given scope for references to `undefined` and reports
+         * all references found.
+         * @param {escope.Scope} scope The scope to check.
+         * @returns {void}
+         */
+        function checkScope(scope) {
+            const undefinedVar = scope.set.get("undefined");
+
+            if (!undefinedVar) {
+                return;
+            }
+
+            const references = undefinedVar.references;
+
+            const defs = undefinedVar.defs;
+
+            // Report non-initializing references (those are covered in defs below)
+            references
+                .filter(ref => !ref.init)
+                .forEach(ref => report(ref.identifier));
+
+            defs.forEach(def => report(def.name));
+        }
+
         return {
+            "Program:exit"() {
+                const globalScope = context.getScope();
+
+                const stack = [globalScope];
 
-            Identifier(node) {
-                if (node.name === "undefined") {
-                    const parent = context.getAncestors().pop();
+                while (stack.length) {
+                    const scope = stack.pop();
 
-                    if (!parent || parent.type !== "MemberExpression" || node !== parent.property || parent.computed) {
-                        context.report({ node, message: "Unexpected use of undefined." });
-                    }
+                    stack.push.apply(stack, scope.childScopes);
+                    checkScope(scope);
                 }
             }
         };

package/lib/rules/no-unexpected-multiline.js

@@ -4,9 +4,16 @@
  */
 "use strict";
 
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("../ast-utils");
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
+
 module.exports = {
     meta: {
         docs: {
@@ -35,14 +42,8 @@ module.exports = {
          * @private
          */
         function checkForBreakAfter(node, msg) {
-            let nodeExpressionEnd = node;
-            let openParen = sourceCode.getTokenAfter(node);
-
-            // Move along until the end of the wrapped expression
-            while (openParen.value === ")") {
-                nodeExpressionEnd = openParen;
-                openParen = sourceCode.getTokenAfter(nodeExpressionEnd);
-            }
+            const openParen = sourceCode.getTokenAfter(node, astUtils.isNotClosingParenToken);
+            const nodeExpressionEnd = sourceCode.getTokenBefore(openParen);
 
             if (openParen.loc.start.line !== nodeExpressionEnd.loc.end.line) {
                 context.report({ node, loc: openParen.loc.start, message: msg, data: { char: openParen.value } });

package/lib/rules/no-unneeded-ternary.js

@@ -67,7 +67,11 @@ module.exports = {
          */
         function invertExpression(node) {
             if (node.type === "BinaryExpression" && Object.prototype.hasOwnProperty.call(OPERATOR_INVERSES, node.operator)) {
-                const operatorToken = sourceCode.getTokensBetween(node.left, node.right).find(token => token.value === node.operator);
+                const operatorToken = sourceCode.getFirstTokenBetween(
+                    node.left,
+                    node.right,
+                    token => token.value === node.operator
+                );
 
                 return sourceCode.getText().slice(node.range[0], operatorToken.range[0]) + OPERATOR_INVERSES[node.operator] + sourceCode.getText().slice(operatorToken.range[1], node.range[1]);
             }

package/lib/rules/no-unused-labels.js

@@ -17,10 +17,13 @@ module.exports = {
             recommended: true
         },
 
-        schema: []
+        schema: [],
+
+        fixable: "code"
     },
 
     create(context) {
+        const sourceCode = context.getSourceCode();
         let scopeInfo = null;
 
         /**
@@ -49,7 +52,19 @@ module.exports = {
                 context.report({
                     node: node.label,
                     message: "'{{name}}:' is defined but never used.",
-                    data: node.label
+                    data: node.label,
+                    fix(fixer) {
+
+                        /*
+                         * Only perform a fix if there are no comments between the label and the body. This will be the case
+                         * when there is exactly one token/comment (the ":") between the label and the body.
+                         */
+                        if (sourceCode.getTokenAfter(node.label, { includeComments: true }) === sourceCode.getTokenBefore(node.body, { includeComments: true })) {
+                            return fixer.removeRange([node.range[0], node.body.range[0]]);
+                        }
+
+                        return null;
+                    }
                 });
             }
 

package/lib/rules/no-unused-vars.js

@@ -62,6 +62,7 @@ module.exports = {
     },
 
     create(context) {
+        const sourceCode = context.getSourceCode();
 
         const DEFINED_MESSAGE = "'{{name}}' is defined but never used.";
         const ASSIGNED_MESSAGE = "'{{name}}' is assigned a value but never used.";
@@ -566,23 +567,8 @@ module.exports = {
          */
         function getLocation(variable) {
             const comment = variable.eslintExplicitGlobalComment;
-            const baseLoc = comment.loc.start;
-            let column = getColumnInComment(variable, comment);
-            const prefix = comment.value.slice(0, column);
-            const lineInComment = (prefix.match(/\n/g) || []).length;
 
-            if (lineInComment > 0) {
-                column -= 1 + prefix.lastIndexOf("\n");
-            } else {
-
-                // 2 is for `/*`
-                column += baseLoc.column + 2;
-            }
-
-            return {
-                line: baseLoc.line + lineInComment,
-                column
-            };
+            return astUtils.getLocationFromRangeIndex(sourceCode, comment.range[0] + 2 + getColumnInComment(variable, comment));
         }
 
         //--------------------------------------------------------------------------

package/lib/rules/no-useless-computed-key.js

@@ -4,6 +4,12 @@
  */
 "use strict";
 
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("../ast-utils");
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -40,9 +46,8 @@ module.exports = {
                         message: MESSAGE_UNNECESSARY_COMPUTED,
                         data: { property: sourceCode.getText(key) },
                         fix(fixer) {
-                            const leftSquareBracket = sourceCode.getFirstToken(node, node.value.generator || node.value.async ? 1 : 0);
-                            const rightSquareBracket = sourceCode.getTokensBetween(node.key, node.value).find(token => token.value === "]");
-
+                            const leftSquareBracket = sourceCode.getFirstToken(node, astUtils.isOpeningBracketToken);
+                            const rightSquareBracket = sourceCode.getFirstTokenBetween(node.key, node.value, astUtils.isClosingBracketToken);
                             const tokensBetween = sourceCode.getTokensBetween(leftSquareBracket, rightSquareBracket, 1);
 
                             if (tokensBetween.slice(0, -1).some((token, index) => sourceCode.getText().slice(token.range[1], tokensBetween[index + 1].range[0]).trim())) {

package/lib/rules/no-useless-concat.js

@@ -23,6 +23,15 @@ function isConcatenation(node) {
     return node.type === "BinaryExpression" && node.operator === "+";
 }
 
+/**
+ * Checks if the given token is a `+` token or not.
+ * @param {Token} token - The token to check.
+ * @returns {boolean} `true` if the token is a `+` token.
+ */
+function isConcatOperatorToken(token) {
+    return token.value === "+" && token.type === "Punctuator";
+}
+
 /**
  * Get's the right most node on the left side of a BinaryExpression with + operator.
  * @param {ASTNode} node - A BinaryExpression node to check.
@@ -85,13 +94,7 @@ module.exports = {
                     astUtils.isStringLiteral(right) &&
                     astUtils.isTokenOnSameLine(left, right)
                 ) {
-
-                    // move warning location to operator
-                    let operatorToken = sourceCode.getTokenAfter(left);
-
-                    while (operatorToken.value !== "+") {
-                        operatorToken = sourceCode.getTokenAfter(operatorToken);
-                    }
+                    const operatorToken = sourceCode.getFirstTokenBetween(left, right, isConcatOperatorToken);
 
                     context.report({
                         node,

package/lib/rules/no-useless-escape.js

@@ -24,7 +24,7 @@ function union(setA, setB) {
     }());
 }
 
-const VALID_STRING_ESCAPES = new Set("\\nrvtbfux\n\r\u2028\u2029");
+const VALID_STRING_ESCAPES = union(new Set("\\nrvtbfux"), astUtils.LINEBREAKS);
 const REGEX_GENERAL_ESCAPES = new Set("\\bcdDfnrsStvwWxu0123456789]");
 const REGEX_NON_CHARCLASS_ESCAPES = union(REGEX_GENERAL_ESCAPES, new Set("^/.$*+?[{}|()B"));
 

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

@@ -45,13 +45,7 @@ function remove(array, element) {
  * @returns {boolean} `true` if the node is removeable.
  */
 function isRemovable(node) {
-    const parent = node.parent;
-
-    return (
-        parent.type === "Program" ||
-        parent.type === "BlockStatement" ||
-        parent.type === "SwitchCase"
-    );
+    return astUtils.STATEMENT_LIST_PARENTS.has(node.parent.type);
 }
 
 /**

package/lib/rules/no-var.js

@@ -274,9 +274,7 @@ module.exports = {
             if (
                 !isLoopAssignee(node) &&
                 !(node.parent.type === "ForStatement" && node.parent.init === node) &&
-                node.parent.type !== "BlockStatement" &&
-                node.parent.type !== "Program" &&
-                node.parent.type !== "SwitchCase"
+                !astUtils.STATEMENT_LIST_PARENTS.has(node.parent.type)
             ) {
 
                 // If the declaration is not in a block, e.g. `if (foo) var bar = 1;`, then it can't be fixed.

package/lib/rules/no-whitespace-before-property.js

@@ -4,6 +4,10 @@
  */
 "use strict";
 
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
 const astUtils = require("../ast-utils");
 
 //------------------------------------------------------------------------------
@@ -29,21 +33,6 @@ module.exports = {
         // Helpers
         //--------------------------------------------------------------------------
 
-        /**
-         * Finds opening bracket token of node's computed property
-         * @param {ASTNode} node - the node to check
-         * @returns {Token} opening bracket token of node's computed property
-         * @private
-         */
-        function findOpeningBracket(node) {
-            let token = sourceCode.getTokenBefore(node.property);
-
-            while (token.value !== "[") {
-                token = sourceCode.getTokenBefore(token);
-            }
-            return token;
-        }
-
         /**
          * Reports whitespace before property token
          * @param {ASTNode} node - the node to report in the event of an error
@@ -87,7 +76,7 @@ module.exports = {
                 }
 
                 if (node.computed) {
-                    rightToken = findOpeningBracket(node);
+                    rightToken = sourceCode.getTokenBefore(node.property, astUtils.isOpeningBracketToken);
                     leftToken = sourceCode.getTokenBefore(rightToken);
                 } else {
                     rightToken = sourceCode.getFirstToken(node.property);