eslint 4.7.2 → 4.11.0

package/lib/rules/no-alert.js

@@ -53,11 +53,10 @@ function findReference(scope, node) {
 /**
  * Checks if the given identifier node is shadowed in the given scope.
  * @param {Object} scope The current scope.
- * @param {Object} globalScope The global scope.
  * @param {string} node The identifier node to check
  * @returns {boolean} Whether or not the name is shadowed.
  */
-function isShadowed(scope, globalScope, node) {
+function isShadowed(scope, node) {
     const reference = findReference(scope, node);
 
     return reference && reference.resolved && reference.resolved.defs.length > 0;
@@ -66,15 +65,15 @@ function isShadowed(scope, globalScope, node) {
 /**
  * Checks if the given identifier node is a ThisExpression in the global scope or the global window property.
  * @param {Object} scope The current scope.
- * @param {Object} globalScope The global scope.
  * @param {string} node The identifier node to check
  * @returns {boolean} Whether or not the node is a reference to the global object.
  */
-function isGlobalThisReferenceOrGlobalWindow(scope, globalScope, node) {
+function isGlobalThisReferenceOrGlobalWindow(scope, node) {
     if (scope.type === "global" && node.type === "ThisExpression") {
         return true;
-    } else if (node.name === "window") {
-        return !isShadowed(scope, globalScope, node);
+    }
+    if (node.name === "window") {
+        return !isShadowed(scope, node);
     }
 
     return false;
@@ -96,14 +95,7 @@ module.exports = {
     },
 
     create(context) {
-        let globalScope;
-
         return {
-
-            Program() {
-                globalScope = context.getScope();
-            },
-
             CallExpression(node) {
                 const callee = node.callee,
                     currentScope = context.getScope();
@@ -112,11 +104,11 @@ module.exports = {
                 if (callee.type === "Identifier") {
                     const identifierName = callee.name;
 
-                    if (!isShadowed(currentScope, globalScope, callee) && isProhibitedIdentifier(callee.name)) {
+                    if (!isShadowed(currentScope, callee) && isProhibitedIdentifier(callee.name)) {
                         report(context, node, identifierName);
                     }
 
-                } else if (callee.type === "MemberExpression" && isGlobalThisReferenceOrGlobalWindow(currentScope, globalScope, callee.object)) {
+                } else if (callee.type === "MemberExpression" && isGlobalThisReferenceOrGlobalWindow(currentScope, callee.object)) {
                     const identifierName = getPropertyName(callee);
 
                     if (isProhibitedIdentifier(identifierName)) {

package/lib/rules/no-await-in-loop.js

@@ -13,8 +13,10 @@ const loopTypes = new Set([
     "DoWhileStatement"
 ]);
 
-// Node types at which we should stop looking for loops. For example, it is fine to declare an async
-// function within a loop, and use await inside of that.
+/*
+ * Node types at which we should stop looking for loops. For example, it is fine to declare an async
+ * function within a loop, and use await inside of that.
+ */
 const boundaryTypes = new Set([
     "FunctionDeclaration",
     "FunctionExpression",
@@ -38,9 +40,11 @@ module.exports = {
                 // Reverse so that we can traverse from the deepest node upwards.
                 ancestors.reverse();
 
-                // Create a set of all the ancestors plus this node so that we can check
-                // if this use of await appears in the body of the loop as opposed to
-                // the right-hand side of a for...of, for example.
+                /*
+                 * Create a set of all the ancestors plus this node so that we can check
+                 * if this use of await appears in the body of the loop as opposed to
+                 * the right-hand side of a for...of, for example.
+                 */
                 const ancestorSet = new Set(ancestors).add(node);
 
                 for (let i = 0; i < ancestors.length; i++) {
@@ -48,14 +52,18 @@ module.exports = {
 
                     if (boundaryTypes.has(ancestor.type)) {
 
-                        // Short-circuit out if we encounter a boundary type. Loops above
-                        // this do not matter.
+                        /*
+                         * Short-circuit out if we encounter a boundary type. Loops above
+                         * this do not matter.
+                         */
                         return;
                     }
                     if (loopTypes.has(ancestor.type)) {
 
-                        // Only report if we are actually in the body or another part that gets executed on
-                        // every iteration.
+                        /*
+                         * Only report if we are actually in the body or another part that gets executed on
+                         * every iteration.
+                         */
                         if (
                             ancestorSet.has(ancestor.body) ||
                             ancestorSet.has(ancestor.test) ||

package/lib/rules/no-bitwise.js

@@ -5,9 +5,11 @@
 
 "use strict";
 
-//
-// Set of bitwise operators.
-//
+/*
+ *
+ * Set of bitwise operators.
+ *
+ */
 const BITWISE_OPERATORS = [
     "^", "|", "&", "<<", ">>", ">>>",
     "^=", "|=", "&=", "<<=", ">>=", ">>>=",

package/lib/rules/no-catch-shadow.js

@@ -51,8 +51,10 @@ module.exports = {
             CatchClause(node) {
                 let scope = context.getScope();
 
-                // When blockBindings is enabled, CatchClause creates its own scope
-                // so start from one upper scope to exclude the current node
+                /*
+                 * When ecmaVersion >= 6, CatchClause creates its own scope
+                 * so start from one upper scope to exclude the current node
+                 */
                 if (scope.block === node) {
                     scope = scope.upper;
                 }

package/lib/rules/no-console.js

@@ -111,7 +111,8 @@ module.exports = {
                 const consoleVar = astUtils.getVariableByName(scope, "console");
                 const shadowed = consoleVar && consoleVar.defs.length > 0;
 
-                /* 'scope.through' includes all references to undefined
+                /*
+                 * 'scope.through' includes all references to undefined
                  * variables. If the variable 'console' is not defined, it uses
                  * 'scope.through'.
                  */

package/lib/rules/no-constant-condition.js

@@ -138,7 +138,7 @@ module.exports = {
         function checkConstantConditionLoopInSet(node) {
             if (loopsInCurrentScope.has(node)) {
                 loopsInCurrentScope.delete(node);
-                context.report({ node, message: "Unexpected constant condition." });
+                context.report({ node: node.test, message: "Unexpected constant condition." });
             }
         }
 
@@ -150,7 +150,7 @@ module.exports = {
          */
         function reportIfConstant(node) {
             if (node.test && isConstant(node.test, true)) {
-                context.report({ node, message: "Unexpected constant condition." });
+                context.report({ node: node.test, message: "Unexpected constant condition." });
             }
         }
 

package/lib/rules/no-control-regex.js

@@ -31,7 +31,8 @@ module.exports = {
         function getRegExp(node) {
             if (node.value instanceof RegExp) {
                 return node.value;
-            } else if (typeof node.value === "string") {
+            }
+            if (typeof node.value === "string") {
 
                 const parent = context.getAncestors().pop();
 

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

@@ -24,8 +24,15 @@ module.exports = {
             recommended: false
         },
 
-        schema: [],
-
+        schema: [{
+            type: "object",
+            properties: {
+                allowElseIf: {
+                    type: "boolean"
+                }
+            },
+            additionalProperties: false
+        }],
         fixable: "code"
     },
 
@@ -59,10 +66,12 @@ module.exports = {
                         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
+                    /*
+                     * 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);
 
@@ -79,10 +88,12 @@ module.exports = {
                         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 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;
                         }
@@ -94,9 +105,11 @@ module.exports = {
                         fixedSource = source;
                     }
 
-                    // Extend the replacement range to include the entire
-                    // function to avoid conflicting with no-useless-return.
-                    // https://github.com/eslint/eslint/issues/8026
+                    /*
+                     * Extend the replacement range to include the entire
+                     * function to avoid conflicting with no-useless-return.
+                     * https://github.com/eslint/eslint/issues/8026
+                     */
                     return new FixTracker(fixer, sourceCode)
                         .retainEnclosingFunction(node)
                         .replaceTextRange([elseToken.range[0], node.range[1]], fixedSource);
@@ -134,13 +147,13 @@ module.exports = {
 
         /**
          * Check to see if the node is valid for evaluation,
-         * meaning it has an else and not an else-if
+         * meaning it has an else.
          *
          * @param {Node} node The node being evaluated
          * @returns {boolean} True if the node is valid
          */
         function hasElse(node) {
-            return node.alternate && node.consequent && node.alternate.type !== "IfStatement";
+            return node.alternate && node.consequent;
         }
 
         /**
@@ -189,14 +202,15 @@ module.exports = {
             return checkForReturnOrIf(node);
         }
 
+
         /**
-         * Check the if statement
+         * Check the if statement, but don't catch else-if blocks.
          * @returns {void}
          * @param {Node} node The node for the if statement to check
          * @private
          */
-        function IfStatement(node) {
-            const parent = context.getAncestors().pop();
+        function checkIfWithoutElse(node) {
+            const parent = node.parent;
             let consequents,
                 alternate;
 
@@ -221,13 +235,40 @@ module.exports = {
             }
         }
 
+        /**
+         * Check the if statement
+         * @returns {void}
+         * @param {Node} node The node for the if statement to check
+         * @private
+         */
+        function checkIfWithElse(node) {
+            const parent = node.parent;
+
+
+            /*
+             * Fixing this would require splitting one statement into two, so no error should
+             * be reported if this node is in a position where only one statement is allowed.
+             */
+            if (!astUtils.STATEMENT_LIST_PARENTS.has(parent.type)) {
+                return;
+            }
+
+            const alternate = node.alternate;
+
+            if (alternate && alwaysReturns(node.consequent)) {
+                displayReport(alternate);
+            }
+        }
+
+        const allowElseIf = !(context.options[0] && context.options[0].allowElseIf === false);
+
         //--------------------------------------------------------------------------
         // Public API
         //--------------------------------------------------------------------------
 
         return {
 
-            "IfStatement:exit": IfStatement
+            "IfStatement:exit": allowElseIf ? checkIfWithoutElse : checkIfWithElse
 
         };
 

package/lib/rules/no-empty-character-class.js

@@ -10,17 +10,17 @@
 //------------------------------------------------------------------------------
 
 /*
-plain-English description of the following regexp:
-0. `^` fix the match at the beginning of the string
-1. `\/`: the `/` that begins the regexp
-2. `([^\\[]|\\.|\[([^\\\]]|\\.)+\])*`: regexp contents; 0 or more of the following
-  2.0. `[^\\[]`: any character that's not a `\` or a `[` (anything but escape sequences and character classes)
-  2.1. `\\.`: an escape sequence
-  2.2. `\[([^\\\]]|\\.)+\]`: a character class that isn't empty
-3. `\/` the `/` that ends the regexp
-4. `[gimuy]*`: optional regexp flags
-5. `$`: fix the match at the end of the string
-*/
+ * plain-English description of the following regexp:
+ * 0. `^` fix the match at the beginning of the string
+ * 1. `\/`: the `/` that begins the regexp
+ * 2. `([^\\[]|\\.|\[([^\\\]]|\\.)+\])*`: regexp contents; 0 or more of the following
+ * 2.0. `[^\\[]`: any character that's not a `\` or a `[` (anything but escape sequences and character classes)
+ * 2.1. `\\.`: an escape sequence
+ * 2.2. `\[([^\\\]]|\\.)+\]`: a character class that isn't empty
+ * 3. `\/` the `/` that ends the regexp
+ * 4. `[gimuy]*`: optional regexp flags
+ * 5. `$`: fix the match at the end of the string
+ */
 const regex = /^\/([^\\[]|\\.|\[([^\\\]]|\\.)+])*\/[gimuy]*$/;
 
 //------------------------------------------------------------------------------

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

@@ -195,10 +195,12 @@ module.exports = {
         function containsAssignment(node) {
             if (node.type === "AssignmentExpression") {
                 return true;
-            } else if (node.type === "ConditionalExpression" &&
+            }
+            if (node.type === "ConditionalExpression" &&
                     (node.consequent.type === "AssignmentExpression" || node.alternate.type === "AssignmentExpression")) {
                 return true;
-            } else if ((node.left && node.left.type === "AssignmentExpression") ||
+            }
+            if ((node.left && node.left.type === "AssignmentExpression") ||
                     (node.right && node.right.type === "AssignmentExpression")) {
                 return true;
             }
@@ -219,7 +221,8 @@ module.exports = {
 
             if (node.type === "ReturnStatement") {
                 return node.argument && containsAssignment(node.argument);
-            } else if (node.type === "ArrowFunctionExpression" && node.body.type !== "BlockStatement") {
+            }
+            if (node.type === "ArrowFunctionExpression" && node.body.type !== "BlockStatement") {
                 return containsAssignment(node.body);
             }
             return containsAssignment(node);
@@ -369,8 +372,10 @@ module.exports = {
                     hasDoubleExcessParens(callee) ||
                     !isIIFE(node) && !hasNewParensException && !(
 
-                        // Allow extra parens around a new expression if
-                        // there are intervening parentheses.
+                        /*
+                         * Allow extra parens around a new expression if
+                         * there are intervening parentheses.
+                         */
                         callee.type === "MemberExpression" &&
                         doesMemberExpressionContainCallExpression(callee)
                     )
@@ -422,8 +427,10 @@ module.exports = {
                 return;
             }
 
-            // If `node.superClass` is a LeftHandSideExpression, parentheses are extra.
-            // Otherwise, parentheses are needed.
+            /*
+             * If `node.superClass` is a LeftHandSideExpression, parentheses are extra.
+             * Otherwise, parentheses are needed.
+             */
             const hasExtraParens = precedence(node.superClass) > PRECEDENCE_OF_UPDATE_EXPR
                 ? hasExcessParens(node.superClass)
                 : hasDoubleExcessParens(node.superClass);
@@ -557,12 +564,16 @@ module.exports = {
                     if (
                         firstLeftToken.value === "let" && (
 
-                            // If `let` is the only thing on the left side of the loop, it's the loop variable: `for ((let) of foo);`
-                            // Removing it will cause a syntax error, because it will be parsed as the start of a VariableDeclarator.
+                            /*
+                             * If `let` is the only thing on the left side of the loop, it's the loop variable: `for ((let) of foo);`
+                             * Removing it will cause a syntax error, because it will be parsed as the start of a VariableDeclarator.
+                             */
                             firstLeftToken.range[1] === node.left.range[1] ||
 
-                            // If `let` is followed by a `[` token, it's a property access on the `let` value: `for ((let[foo]) of bar);`
-                            // Removing it will cause the property access to be parsed as a destructuring declaration of `foo` instead.
+                            /*
+                             * If `let` is followed by a `[` token, it's a property access on the `let` value: `for ((let[foo]) of bar);`
+                             * Removing it will cause the property access to be parsed as a destructuring declaration of `foo` instead.
+                             */
                             astUtils.isOpeningBracketToken(
                                 sourceCode.getTokenAfter(firstLeftToken, astUtils.isNotClosingParenToken)
                             )

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

@@ -42,9 +42,11 @@ module.exports = {
                 message: "Unnecessary semicolon.",
                 fix(fixer) {
 
-                    // Expand the replacement range to include the surrounding
-                    // tokens to avoid conflicting with semi.
-                    // https://github.com/eslint/eslint/issues/7928
+                    /*
+                     * Expand the replacement range to include the surrounding
+                     * tokens to avoid conflicting with semi.
+                     * https://github.com/eslint/eslint/issues/7928
+                     */
                     return new FixTracker(fixer, context.getSourceCode())
                         .retainSurroundingTokens(nodeOrToken)
                         .remove(nodeOrToken);

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

@@ -49,8 +49,10 @@ module.exports = {
             if (reference.init === false &&
                 reference.isWrite() &&
 
-                // Destructuring assignments can have multiple default value,
-                // so possibly there are multiple writeable references for the same identifier.
+                /*
+                 * Destructuring assignments can have multiple default value,
+                 * so possibly there are multiple writeable references for the same identifier.
+                 */
                 (index === 0 || references[index - 1].identifier !== identifier)
             ) {
                 context.report({

package/lib/rules/no-implicit-coercion.js

@@ -189,12 +189,12 @@ module.exports = {
         const sourceCode = context.getSourceCode();
 
         /**
-        * Reports an error and autofixes the node
-        * @param {ASTNode} node - An ast node to report the error on.
-        * @param {string} recommendation - The recommended code for the issue
-        * @param {bool} shouldFix - Whether this report should fix the node
-        * @returns {void}
-        */
+         * Reports an error and autofixes the node
+         * @param {ASTNode} node - An ast node to report the error on.
+         * @param {string} recommendation - The recommended code for the issue
+         * @param {bool} shouldFix - Whether this report should fix the node
+         * @returns {void}
+         */
         function report(node, recommendation, shouldFix) {
             shouldFix = typeof shouldFix === "undefined" ? true : shouldFix;
 

package/lib/rules/no-implied-eval.js

@@ -125,7 +125,8 @@ module.exports = {
             "CallExpression:exit"(node) {
                 if (node === last(last(impliedEvalAncestorsStack))) {
 
-                    /* Destroys the entire sub-stack, rather than just using
+                    /*
+                     * Destroys the entire sub-stack, rather than just using
                      * last(impliedEvalAncestorsStack).pop(), as a CallExpression is
                      * always the bottom of a impliedEvalAncestorsStack substack.
                      */

package/lib/rules/no-label-var.js

@@ -54,8 +54,10 @@ module.exports = {
                 // Fetch the innermost scope.
                 const scope = context.getScope();
 
-                // Recursively find the identifier walking up the scope, starting
-                // with the innermost scope.
+                /*
+                 * Recursively find the identifier walking up the scope, starting
+                 * with the innermost scope.
+                 */
                 if (findIdentifier(scope, node.label.name)) {
                     context.report({ node, message: "Found identifier with same name as label." });
                 }

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

@@ -30,7 +30,7 @@ module.exports = {
          * Reports a node as invalid.
          * @param {ASTNode} node - The node to be reported.
          * @returns {void}
-        */
+         */
         function report(node) {
             const message = node.parent.type === "BlockStatement" ? "Nested block is redundant." : "Block is redundant.";
 
@@ -41,7 +41,7 @@ module.exports = {
          * 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(node) {
             return node.parent.type === "BlockStatement" ||
                 node.parent.type === "Program" ||
@@ -54,7 +54,7 @@ module.exports = {
          * Checks the enclosing block of the current node for block-level bindings,
          * and "marks it" as valid if any.
          * @returns {void}
-        */
+         */
         function markLoneBlock() {
             if (loneBlocks.length === 0) {
                 return;

package/lib/rules/no-lonely-if.js

@@ -45,7 +45,8 @@ module.exports = {
                             const lastIfToken = sourceCode.getLastToken(node.consequent);
                             const sourceText = sourceCode.getText();
 
-                            if (sourceText.slice(openingElseCurly.range[1], node.range[0]).trim() || sourceText.slice(node.range[1], closingElseCurly.range[0]).trim()) {
+                            if (sourceText.slice(openingElseCurly.range[1],
+                                node.range[0]).trim() || sourceText.slice(node.range[1], closingElseCurly.range[0]).trim()) {
 
                                 // Don't fix if there are any non-whitespace characters interfering (e.g. comments)
                                 return null;

package/lib/rules/no-loop-func.js

@@ -88,12 +88,11 @@ function getTopLoopNode(node, excludedNode) {
  * Checks whether a given reference which refers to an upper scope's variable is
  * safe or not.
  *
- * @param {ASTNode} funcNode - A target function node.
  * @param {ASTNode} loopNode - A containing loop node.
  * @param {eslint-scope.Reference} reference - A reference to check.
  * @returns {boolean} `true` if the reference is safe or not.
  */
-function isSafe(funcNode, loopNode, reference) {
+function isSafe(loopNode, reference) {
     const variable = reference.resolved;
     const definition = variable && variable.defs[0];
     const declaration = definition && definition.parent;
@@ -106,8 +105,10 @@ function isSafe(funcNode, loopNode, reference) {
         return true;
     }
 
-    // Variables which are declared by `let` in the loop is safe.
-    // It's a different instance from the next loop step's.
+    /*
+     * Variables which are declared by `let` in the loop is safe.
+     * It's a different instance from the next loop step's.
+     */
     if (kind === "let" &&
         declaration.range[0] > loopNode.range[0] &&
         declaration.range[1] < loopNode.range[1]
@@ -115,8 +116,10 @@ function isSafe(funcNode, loopNode, reference) {
         return true;
     }
 
-    // WriteReferences which exist after this border are unsafe because those
-    // can modify the variable.
+    /*
+     * WriteReferences which exist after this border are unsafe because those
+     * can modify the variable.
+     */
     const border = getTopLoopNode(
         loopNode,
         (kind === "let") ? declaration : null
@@ -183,7 +186,7 @@ module.exports = {
             const references = context.getScope().through;
 
             if (references.length > 0 &&
-                !references.every(isSafe.bind(null, node, loopNode))
+                !references.every(isSafe.bind(null, loopNode))
             ) {
                 context.report({ node, message: "Don't make functions within a loop." });
             }

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

@@ -104,14 +104,16 @@ module.exports = {
 
                 // "var x = require('util');"
                 return DECL_REQUIRE;
-            } else if (allowCall &&
+            }
+            if (allowCall &&
                 initExpression.type === "CallExpression" &&
                 initExpression.callee.type === "CallExpression"
             ) {
 
                 // "var x = require('diagnose')('sub-module');"
                 return getDeclarationType(initExpression.callee);
-            } else if (initExpression.type === "MemberExpression") {
+            }
+            if (initExpression.type === "MemberExpression") {
 
                 // "var x = require('glob').Glob;"
                 return getDeclarationType(initExpression.object);
@@ -131,7 +133,8 @@ module.exports = {
 
                 // "var x = require('glob').Glob;"
                 return inferModuleType(initExpression.object);
-            } else if (initExpression.arguments.length === 0) {
+            }
+            if (initExpression.arguments.length === 0) {
 
                 // "var x = require();"
                 return REQ_COMPUTED;
@@ -149,7 +152,8 @@ module.exports = {
 
                 // "var fs = require('fs');"
                 return REQ_CORE;
-            } else if (/^\.{0,2}\//.test(arg.value)) {
+            }
+            if (/^\.{0,2}\//.test(arg.value)) {
 
                 // "var utils = require('./utils');"
                 return REQ_FILE;

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

@@ -53,8 +53,10 @@ module.exports = {
             if (reference.init === false &&
                 reference.isWrite() &&
 
-                // Destructuring assignments can have multiple default value,
-                // so possibly there are multiple writeable references for the same identifier.
+                /*
+                 * Destructuring assignments can have multiple default value,
+                 * so possibly there are multiple writeable references for the same identifier.
+                 */
                 (index === 0 || references[index - 1].identifier !== identifier)
             ) {
                 context.report({