eslint 3.14.0 → 3.16.1

package/lib/rules/eqeqeq.js

@@ -5,6 +5,12 @@
 
 "use strict";
 
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("../ast-utils");
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -57,9 +63,9 @@ module.exports = {
         const options = context.options[1] || {};
         const sourceCode = context.getSourceCode();
 
-        const nullOption = (config === "always") ?
-            options.null || "always" :
-            "ignore";
+        const nullOption = (config === "always")
+            ? options.null || "always"
+            : "ignore";
         const enforceRuleForNull = (nullOption === "always");
         const enforceInverseRuleForNull = (nullOption === "never");
 
@@ -100,8 +106,7 @@ module.exports = {
          * @private
          */
         function isNullCheck(node) {
-            return (node.right.type === "Literal" && node.right.value === null) ||
-                    (node.left.type === "Literal" && node.left.value === null);
+            return astUtils.isNullLiteral(node.right) || astUtils.isNullLiteral(node.left);
         }
 
         /**
@@ -134,7 +139,11 @@ module.exports = {
 
                     // If the comparison is a `typeof` comparison or both sides are literals with the same type, then it's safe to fix.
                     if (isTypeOfBinary(node) || areLiteralsAndSameType(node)) {
-                        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 fixer.replaceText(operatorToken, expectedOperator);
                     }

package/lib/rules/func-call-spacing.js

@@ -5,6 +5,12 @@
 
 "use strict";
 
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("../ast-utils");
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -67,19 +73,10 @@ module.exports = {
          * @private
          */
         function checkSpacing(node) {
+            const lastToken = sourceCode.getLastToken(node);
             const lastCalleeToken = sourceCode.getLastToken(node.callee);
-            let prevToken = lastCalleeToken;
-            let parenToken = sourceCode.getTokenAfter(lastCalleeToken);
-
-            // advances to an open parenthesis.
-            while (
-                parenToken &&
-                parenToken.range[1] < node.range[1] &&
-                parenToken.value !== "("
-            ) {
-                prevToken = parenToken;
-                parenToken = sourceCode.getTokenAfter(parenToken);
-            }
+            const parenToken = sourceCode.getFirstTokenBetween(lastCalleeToken, lastToken, astUtils.isOpeningParenToken);
+            const prevToken = parenToken && sourceCode.getTokenBefore(parenToken);
 
             // Parens in NewExpression are optional
             if (!(parenToken && parenToken.range[1] < node.range[1])) {
@@ -88,7 +85,7 @@ module.exports = {
 
             const textBetweenTokens = text.slice(prevToken.range[1], parenToken.range[0]).replace(/\/\*.*?\*\//g, "");
             const hasWhitespace = /\s/.test(textBetweenTokens);
-            const hasNewline = hasWhitespace && /[\n\r\u2028\u2029]/.test(textBetweenTokens);
+            const hasNewline = hasWhitespace && astUtils.LINEBREAK_MATCHER.test(textBetweenTokens);
 
             /*
              * never allowNewlines hasWhitespace hasNewline message

package/lib/rules/func-name-matching.js

@@ -155,7 +155,7 @@ module.exports = {
                     return;
                 }
 
-                const isProp = node.left.type === "MemberExpression" ? true : false;
+                const isProp = node.left.type === "MemberExpression";
                 const name = isProp ? astUtils.getStaticPropertyName(node.left) : node.left.name;
 
                 if (node.right.id && isIdentifier(name) && shouldWarn(name, node.right.id.name)) {

package/lib/rules/generator-star-spacing.js

@@ -55,21 +55,26 @@ module.exports = {
         const sourceCode = context.getSourceCode();
 
         /**
-         * Gets `*` token from a given node.
+         * Checks if the given token is a star token or not.
          *
-         * @param {ASTNode} node - A node to get `*` token. This is one of
-         *      FunctionDeclaration, FunctionExpression, Property, and
-         *      MethodDefinition.
-         * @returns {Token} `*` token.
+         * @param {Token} token - The token to check.
+         * @returns {boolean} `true` if the token is a star token.
          */
-        function getStarToken(node) {
-            let token = sourceCode.getFirstToken(node);
-
-            while (token.value !== "*") {
-                token = sourceCode.getTokenAfter(token);
-            }
+        function isStarToken(token) {
+            return token.value === "*" && token.type === "Punctuator";
+        }
 
-            return token;
+        /**
+         * Gets the generator star token of the given function node.
+         *
+         * @param {ASTNode} node - The function node to get.
+         * @returns {Token} Found star token.
+         */
+        function getStarToken(node) {
+            return sourceCode.getFirstToken(
+                (node.parent.method || node.parent.type === "MethodDefinition") ? node.parent : node,
+                isStarToken
+            );
         }
 
         /**
@@ -116,17 +121,11 @@ module.exports = {
          * @returns {void}
          */
         function checkFunction(node) {
-            let starToken;
-
             if (!node.generator) {
                 return;
             }
 
-            if (node.parent.method || node.parent.type === "MethodDefinition") {
-                starToken = getStarToken(node.parent);
-            } else {
-                starToken = getStarToken(node);
-            }
+            const starToken = getStarToken(node);
 
             // Only check before when preceded by `function`|`static` keyword
             const prevToken = sourceCode.getTokenBefore(starToken);

package/lib/rules/global-require.js

@@ -29,9 +29,9 @@ function findReference(scope, node) {
     /* istanbul ignore else: correctly returns null */
     if (references.length === 1) {
         return references[0];
-    } else {
-        return null;
     }
+    return null;
+
 }
 
 /**

package/lib/rules/id-blacklist.js

@@ -55,8 +55,8 @@ module.exports = {
          * @returns {boolean} whether an error should be reported or not
          */
         function shouldReport(effectiveParent, name) {
-            return effectiveParent.type !== "CallExpression"
-                && effectiveParent.type !== "NewExpression" &&
+            return effectiveParent.type !== "CallExpression" &&
+                effectiveParent.type !== "NewExpression" &&
                 isInvalid(name);
         }
 

package/lib/rules/id-length.js

@@ -104,9 +104,9 @@ module.exports = {
                 if (isValidExpression && (isValidExpression === true || isValidExpression(parent, node))) {
                     context.report({
                         node,
-                        message: isShort ?
-                            "Identifier name '{{name}}' is too short (< {{min}})." :
-                            "Identifier name '{{name}}' is too long (> {{max}}).",
+                        message: isShort
+                            ? "Identifier name '{{name}}' is too short (< {{min}})."
+                            : "Identifier name '{{name}}' is too long (> {{max}}).",
                         data: { name, min: minLength, max: maxLength }
                     });
                 }

package/lib/rules/id-match.js

@@ -63,8 +63,8 @@ module.exports = {
          * @returns {boolean} whether an error should be reported or not
          */
         function shouldReport(effectiveParent, name) {
-            return effectiveParent.type !== "CallExpression"
-                && effectiveParent.type !== "NewExpression" &&
+            return effectiveParent.type !== "CallExpression" &&
+                effectiveParent.type !== "NewExpression" &&
                 isInvalid(name);
         }
 

package/lib/rules/indent.js

@@ -8,6 +8,12 @@
 
 "use strict";
 
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("../ast-utils");
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -435,15 +441,10 @@ module.exports = {
          * @returns {void}
          */
         function checkLastReturnStatementLineIndent(node, firstLineIndent) {
-            const nodeLastToken = sourceCode.getLastToken(node);
-            let lastToken = nodeLastToken;
 
             // in case if return statement ends with ');' we have traverse back to ')'
             // otherwise we'll measure indent for ';' and replace ')'
-            while (lastToken.value !== ")") {
-                lastToken = sourceCode.getTokenBefore(lastToken);
-            }
-
+            const lastToken = sourceCode.getLastToken(node, astUtils.isClosingParenToken);
             const textBeforeClosingParenthesis = sourceCode.getText(lastToken, lastToken.loc.start.column).slice(0, -1);
 
             if (textBeforeClosingParenthesis.trim()) {
@@ -691,9 +692,9 @@ module.exports = {
         function isFirstArrayElementOnSameLine(node) {
             if (node.type === "ArrayExpression" && node.elements[0]) {
                 return node.elements[0].loc.start.line === node.loc.start.line && node.elements[0].type === "ObjectExpression";
-            } else {
-                return false;
             }
+            return false;
+
         }
 
         /**
@@ -729,7 +730,7 @@ module.exports = {
                         } else if (parent.type === "ObjectExpression" || parent.type === "ArrayExpression") {
                             const parentElements = node.parent.type === "ObjectExpression" ? node.parent.properties : node.parent.elements;
 
-                            if (parentElements[0].loc.start.line === parent.loc.start.line && parentElements[0].loc.end.line !== parent.loc.start.line) {
+                            if (parentElements[0] && parentElements[0].loc.start.line === parent.loc.start.line && parentElements[0].loc.end.line !== parent.loc.start.line) {
 
                                 /*
                                  * If the first element of the array spans multiple lines, don't increase the expected indentation of the rest.
@@ -936,20 +937,20 @@ module.exports = {
 
             if (caseIndentStore[switchNode.loc.start.line]) {
                 return caseIndentStore[switchNode.loc.start.line];
+            }
+            if (typeof switchIndent === "undefined") {
+                switchIndent = getNodeIndent(switchNode).goodChar;
+            }
+
+            if (switchNode.cases.length > 0 && options.SwitchCase === 0) {
+                caseIndent = switchIndent;
             } else {
-                if (typeof switchIndent === "undefined") {
-                    switchIndent = getNodeIndent(switchNode).goodChar;
-                }
+                caseIndent = switchIndent + (indentSize * options.SwitchCase);
+            }
 
-                if (switchNode.cases.length > 0 && options.SwitchCase === 0) {
-                    caseIndent = switchIndent;
-                } else {
-                    caseIndent = switchIndent + (indentSize * options.SwitchCase);
-                }
+            caseIndentStore[switchNode.loc.start.line] = caseIndent;
+            return caseIndent;
 
-                caseIndentStore[switchNode.loc.start.line] = caseIndent;
-                return caseIndent;
-            }
         }
 
         /**

package/lib/rules/key-spacing.js

@@ -4,6 +4,12 @@
  */
 "use strict";
 
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("../ast-utils");
+
 //------------------------------------------------------------------------------
 // Helpers
 //------------------------------------------------------------------------------
@@ -15,7 +21,7 @@
  * @returns {boolean} True if str contains a line terminator.
  */
 function containsLineTerminator(str) {
-    return /[\n\r\u2028\u2029]/.test(str);
+    return astUtils.LINEBREAK_MATCHER.test(str);
 }
 
 /**
@@ -364,14 +370,9 @@ module.exports = {
          * @returns {ASTNode} The last token before a colon punctuator.
          */
         function getLastTokenBeforeColon(node) {
-            let prevNode;
+            const colonToken = sourceCode.getTokenAfter(node, astUtils.isColonToken);
 
-            while (node && (node.type !== "Punctuator" || node.value !== ":")) {
-                prevNode = node;
-                node = sourceCode.getTokenAfter(node);
-            }
-
-            return prevNode;
+            return sourceCode.getTokenBefore(colonToken);
         }
 
         /**
@@ -381,12 +382,7 @@ module.exports = {
          * @returns {ASTNode} The colon punctuator.
          */
         function getNextColon(node) {
-
-            while (node && (node.type !== "Punctuator" || node.value !== ":")) {
-                node = sourceCode.getTokenAfter(node);
-            }
-
-            return node;
+            return sourceCode.getTokenAfter(node, astUtils.isColonToken);
         }
 
         /**
@@ -417,8 +413,8 @@ module.exports = {
         function report(property, side, whitespace, expected, mode) {
             const diff = whitespace.length - expected,
                 nextColon = getNextColon(property.key),
-                tokenBeforeColon = sourceCode.getTokenOrCommentBefore(nextColon),
-                tokenAfterColon = sourceCode.getTokenOrCommentAfter(nextColon),
+                tokenBeforeColon = sourceCode.getTokenBefore(nextColon, { includeComments: true }),
+                tokenAfterColon = sourceCode.getTokenAfter(nextColon, { includeComments: true }),
                 isKeySide = side === "key",
                 locStart = isKeySide ? tokenBeforeColon.loc.start : tokenAfterColon.loc.start,
                 isExtra = diff > 0,
@@ -628,15 +624,16 @@ module.exports = {
                 }
             };
 
-        } else { // Obey beforeColon and afterColon in each property as configured
+        }
+
+        // Obey beforeColon and afterColon in each property as configured
+        return {
+            Property(node) {
+                verifySpacing(node, isSingleLine(node.parent) ? singleLineOptions : multiLineOptions);
+            }
+        };
 
-            return {
-                Property(node) {
-                    verifySpacing(node, isSingleLine(node.parent) ? singleLineOptions : multiLineOptions);
-                }
-            };
 
-        }
 
     }
 };

package/lib/rules/keyword-spacing.js

@@ -342,11 +342,7 @@ module.exports = {
          */
         function checkSpacingAroundTokenBefore(node) {
             if (node) {
-                let token = sourceCode.getTokenBefore(node);
-
-                while (token.type !== "Keyword") {
-                    token = sourceCode.getTokenBefore(token);
-                }
+                const token = sourceCode.getTokenBefore(node, astUtils.isKeywordToken);
 
                 checkSpacingAround(token);
             }
@@ -439,14 +435,7 @@ module.exports = {
          */
         function checkSpacingForForOfStatement(node) {
             checkSpacingAroundFirstToken(node);
-
-            // `of` is not a keyword token.
-            let token = sourceCode.getTokenBefore(node.right);
-
-            while (token.value !== "of") {
-                token = sourceCode.getTokenBefore(token);
-            }
-            checkSpacingAround(token);
+            checkSpacingAround(sourceCode.getTokenBefore(node.right, astUtils.isNotOpeningParenToken));
         }
 
         /**

package/lib/rules/line-comment-position.js

@@ -77,7 +77,7 @@ module.exports = {
                     return;
                 }
 
-                const previous = sourceCode.getTokenOrCommentBefore(node);
+                const previous = sourceCode.getTokenBefore(node, { includeComments: true });
                 const isOnSameLine = previous && previous.loc.end.line === node.loc.start.line;
 
                 if (above) {

package/lib/rules/linebreak-style.js

@@ -5,6 +5,12 @@
 
 "use strict";
 
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("../ast-utils");
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -60,7 +66,7 @@ module.exports = {
                     expectedLF = linebreakStyle === "unix",
                     expectedLFChars = expectedLF ? "\n" : "\r\n",
                     source = sourceCode.getText(),
-                    pattern = /\r\n|\r|\n|\u2028|\u2029/g;
+                    pattern = astUtils.createGlobalLinebreakMatcher();
                 let match;
 
                 let i = 0;

package/lib/rules/lines-around-comment.js

@@ -139,7 +139,7 @@ module.exports = {
 
             token = node;
             do {
-                token = sourceCode.getTokenOrCommentBefore(token);
+                token = sourceCode.getTokenBefore(token, { includeComments: true });
             } while (isCommentNodeType(token));
 
             if (token && astUtils.isTokenOnSameLine(token, node)) {
@@ -148,7 +148,7 @@ module.exports = {
 
             token = node;
             do {
-                token = sourceCode.getTokenOrCommentAfter(token);
+                token = sourceCode.getTokenAfter(token, { includeComments: true });
             } while (isCommentNodeType(token));
 
             if (token && astUtils.isTokenOnSameLine(node, token)) {
@@ -300,8 +300,8 @@ module.exports = {
                 return;
             }
 
-            const previousTokenOrComment = sourceCode.getTokenOrCommentBefore(node);
-            const nextTokenOrComment = sourceCode.getTokenOrCommentAfter(node);
+            const previousTokenOrComment = sourceCode.getTokenBefore(node, { includeComments: true });
+            const nextTokenOrComment = sourceCode.getTokenAfter(node, { includeComments: true });
 
             // check for newline before
             if (!exceptionStartAllowed && before && !lodash.includes(commentAndEmptyLines, prevLineNum) &&

package/lib/rules/lines-around-directive.js

@@ -57,7 +57,7 @@ module.exports = {
          * @returns {boolean} Whether or not the passed in node is preceded by a blank newline.
          */
         function hasNewlineBefore(node) {
-            const tokenBefore = sourceCode.getTokenOrCommentBefore(node);
+            const tokenBefore = sourceCode.getTokenBefore(node, { includeComments: true });
             const tokenLineBefore = tokenBefore ? tokenBefore.loc.end.line : 0;
 
             return node.loc.start.line - tokenLineBefore >= 2;
@@ -86,7 +86,7 @@ module.exports = {
          */
         function hasNewlineAfter(node) {
             const lastToken = getLastTokenOnLine(node);
-            const tokenAfter = sourceCode.getTokenOrCommentAfter(lastToken);
+            const tokenAfter = sourceCode.getTokenAfter(lastToken, { includeComments: true });
 
             return tokenAfter.loc.start.line - lastToken.loc.end.line >= 2;
         }
@@ -131,7 +131,7 @@ module.exports = {
             }
 
             const firstDirective = directives[0];
-            const hasTokenOrCommentBefore = !!sourceCode.getTokenOrCommentBefore(firstDirective);
+            const hasTokenOrCommentBefore = !!sourceCode.getTokenBefore(firstDirective, { includeComments: true });
 
             // Only check before the first directive if it is preceded by a comment or if it is at the top of
             // the file and expectLineBefore is set to "never". This is to not force a newline at the top of

package/lib/rules/max-lines.js

@@ -90,7 +90,7 @@ module.exports = {
 
             token = comment;
             do {
-                token = sourceCode.getTokenOrCommentBefore(token);
+                token = sourceCode.getTokenBefore(token, { includeComments: true });
             } while (isCommentNodeType(token));
 
             if (token && astUtils.isTokenOnSameLine(token, comment)) {
@@ -99,7 +99,7 @@ module.exports = {
 
             token = comment;
             do {
-                token = sourceCode.getTokenOrCommentAfter(token);
+                token = sourceCode.getTokenAfter(token, { includeComments: true });
             } while (isCommentNodeType(token));
 
             if (token && astUtils.isTokenOnSameLine(comment, token)) {

package/lib/rules/max-statements-per-line.js

@@ -4,6 +4,12 @@
  */
 "use strict";
 
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("../ast-utils");
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -74,12 +80,7 @@ module.exports = {
          * @returns {Token} The actual last token.
          */
         function getActualLastToken(node) {
-            let lastToken = sourceCode.getLastToken(node);
-
-            if (lastToken.value === ";") {
-                lastToken = sourceCode.getTokenBefore(lastToken);
-            }
-            return lastToken;
+            return sourceCode.getLastToken(node, astUtils.isNotSemicolonToken);
         }
 
         /**

package/lib/rules/new-cap.js

@@ -180,9 +180,9 @@ module.exports = {
                 return "non-alpha";
             } else if (firstChar === firstCharLower) {
                 return "lower";
-            } else {
-                return "upper";
             }
+            return "upper";
+
         }
 
         /**

package/lib/rules/newline-after-var.js

@@ -5,6 +5,12 @@
 
 "use strict";
 
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("../ast-utils");
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -201,8 +207,7 @@ module.exports = {
                     message: NEVER_MESSAGE,
                     data: { identifier: node.name },
                     fix(fixer) {
-                        const NEWLINE_REGEX = /\r\n|\r|\n|\u2028|\u2029/;
-                        const linesBetween = sourceCode.getText().slice(lastToken.range[1], nextToken.range[0]).split(NEWLINE_REGEX);
+                        const linesBetween = sourceCode.getText().slice(lastToken.range[1], nextToken.range[0]).split(astUtils.LINEBREAK_MATCHER);
 
                         return fixer.replaceTextRange([lastToken.range[1], nextToken.range[0]], `${linesBetween.slice(0, -1).join("")}\n${linesBetween[linesBetween.length - 1]}`);
                     }

package/lib/rules/newline-before-return.js

@@ -60,9 +60,9 @@ module.exports = {
                 return isPrecededByTokens(node, ["do"]);
             } else if (parentType === "SwitchCase") {
                 return isPrecededByTokens(node, [":"]);
-            } else {
-                return isPrecededByTokens(node, [")"]);
             }
+            return isPrecededByTokens(node, [")"]);
+
         }
 
         /**

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;