eslint 3.13.1 → 3.16.0

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

@@ -31,7 +31,7 @@ module.exports = {
                         },
                         after: {
                             enum: ["always", "never"]
-                        },
+                        }
                     },
                     additionalProperties: false,
                     minProperties: 2
@@ -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)) {
@@ -134,7 +134,7 @@ module.exports = {
                         message: "File must be at most {{max}} lines long. It's {{actual}} lines long.",
                         data: {
                             max,
-                            actual: lines.length,
+                            actual: lines.length
                         }
                     });
                 }

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

@@ -4,6 +4,12 @@
  */
 "use strict";
 
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("../ast-utils");
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -60,7 +66,7 @@ module.exports = {
                     data: {
                         numberOfStatementsOnThisLine,
                         maxStatementsPerLine,
-                        statements: numberOfStatementsOnThisLine === 1 ? "statement" : "statements",
+                        statements: numberOfStatementsOnThisLine === 1 ? "statement" : "statements"
                     }
                 });
             }
@@ -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-await-in-loop.js

@@ -10,7 +10,7 @@ const loopTypes = new Set([
     "ForOfStatement",
     "ForInStatement",
     "WhileStatement",
-    "DoWhileStatement",
+    "DoWhileStatement"
 ]);
 
 // Node types at which we should stop looking for loops. For example, it is fine to declare an async
@@ -18,7 +18,7 @@ const loopTypes = new Set([
 const boundaryTypes = new Set([
     "FunctionDeclaration",
     "FunctionExpression",
-    "ArrowFunctionExpression",
+    "ArrowFunctionExpression"
 ]);
 
 module.exports = {
@@ -26,9 +26,9 @@ module.exports = {
         docs: {
             description: "disallow `await` inside of loops",
             category: "Possible Errors",
-            recommended: false,
+            recommended: false
         },
-        schema: [],
+        schema: []
     },
     create(context) {
         return {
@@ -69,7 +69,7 @@ module.exports = {
                         }
                     }
                 }
-            },
+            }
         };
     }
 };

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-dupe-keys.js

@@ -123,7 +123,7 @@ module.exports = {
                         node: info.node,
                         loc: node.key.loc,
                         message: "Duplicate key '{{name}}'.",
-                        data: { name },
+                        data: { name }
                     });
                 }