eslint 3.13.1 → 3.16.0

package/lib/rules/no-throw-literal.js

@@ -5,44 +5,7 @@
 
 "use strict";
 
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-/**
- * Determine if a node has a possiblity to be an Error object
- * @param  {ASTNode}  node  ASTNode to check
- * @returns {boolean}       True if there is a chance it contains an Error obj
- */
-function couldBeError(node) {
-    switch (node.type) {
-        case "Identifier":
-        case "CallExpression":
-        case "NewExpression":
-        case "MemberExpression":
-        case "TaggedTemplateExpression":
-        case "YieldExpression":
-            return true; // possibly an error object.
-
-        case "AssignmentExpression":
-            return couldBeError(node.right);
-
-        case "SequenceExpression": {
-            const exprs = node.expressions;
-
-            return exprs.length !== 0 && couldBeError(exprs[exprs.length - 1]);
-        }
-
-        case "LogicalExpression":
-            return couldBeError(node.left) || couldBeError(node.right);
-
-        case "ConditionalExpression":
-            return couldBeError(node.consequent) || couldBeError(node.alternate);
-
-        default:
-            return false;
-    }
-}
+const astUtils = require("../ast-utils");
 
 //------------------------------------------------------------------------------
 // Rule Definition
@@ -64,7 +27,7 @@ module.exports = {
         return {
 
             ThrowStatement(node) {
-                if (!couldBeError(node.argument)) {
+                if (!astUtils.couldBeError(node.argument)) {
                     context.report({ node, message: "Expected an object to be thrown." });
                 } else if (node.argument.type === "Identifier") {
                     if (node.argument.name === "undefined") {

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

@@ -42,6 +42,9 @@ module.exports = {
                             args: {
                                 enum: ["all", "after-used", "none"]
                             },
+                            ignoreRestSiblings: {
+                                type: "boolean"
+                            },
                             argsIgnorePattern: {
                                 type: "string"
                             },
@@ -59,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.";
@@ -66,6 +70,7 @@ module.exports = {
         const config = {
             vars: "all",
             args: "after-used",
+            ignoreRestSiblings: false,
             caughtErrors: "none"
         };
 
@@ -77,6 +82,7 @@ module.exports = {
             } else {
                 config.vars = firstOption.vars || config.vars;
                 config.args = firstOption.args || config.args;
+                config.ignoreRestSiblings = firstOption.ignoreRestSiblings || config.ignoreRestSiblings;
                 config.caughtErrors = firstOption.caughtErrors || config.caughtErrors;
 
                 if (firstOption.varsIgnorePattern) {
@@ -120,9 +126,33 @@ module.exports = {
                 }
 
                 return node.parent.type.indexOf("Export") === 0;
-            } else {
-                return false;
             }
+            return false;
+
+        }
+
+        /**
+         * Determines if a variable has a sibling rest property
+         * @param {Variable} variable - EScope variable object.
+         * @returns {boolean} True if the variable is exported, false if not.
+         * @private
+         */
+        function hasRestSpreadSibling(variable) {
+            if (config.ignoreRestSiblings) {
+                const restProperties = new Set(["ExperimentalRestProperty", "RestProperty"]);
+
+                return variable.defs
+                    .filter(def => def.name.type === "Identifier")
+                    .some(def => (
+                        def.node.id &&
+                        def.node.id.type === "ObjectPattern" &&
+                        def.node.id.properties.length &&
+                        restProperties.has(def.node.id.properties[def.node.id.properties.length - 1].type) &&  // last property is a rest property
+                        !restProperties.has(def.name.parent.type)  // variable is sibling of the rest property
+                    ));
+            }
+
+            return false;
         }
 
         /**
@@ -495,7 +525,7 @@ module.exports = {
                         }
                     }
 
-                    if (!isUsedVariable(variable) && !isExported(variable)) {
+                    if (!isUsedVariable(variable) && !isExported(variable) && !hasRestSpreadSibling(variable)) {
                         unusedVars.push(variable);
                     }
                 }
@@ -537,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-use-before-define.js

@@ -21,22 +21,17 @@ const FOR_IN_OF_TYPE = /^For(?:In|Of)Statement$/;
 function parseOptions(options) {
     let functions = true;
     let classes = true;
+    let variables = true;
 
     if (typeof options === "string") {
         functions = (options !== "nofunc");
     } else if (typeof options === "object" && options !== null) {
         functions = options.functions !== false;
         classes = options.classes !== false;
+        variables = options.variables !== false;
     }
 
-    return { functions, classes };
-}
-
-/**
- * @returns {boolean} `false`.
- */
-function alwaysFalse() {
-    return false;
+    return { functions, classes, variables };
 }
 
 /**
@@ -64,14 +59,16 @@ function isOuterClass(variable, reference) {
 }
 
 /**
- * Checks whether or not a given variable is a function declaration or a class declaration in an upper function scope.
- *
- * @param {escope.Variable} variable - A variable to check.
- * @param {escope.Reference} reference - A reference to check.
- * @returns {boolean} `true` if the variable is a function declaration or a class declaration.
- */
-function isFunctionOrOuterClass(variable, reference) {
-    return isFunction(variable, reference) || isOuterClass(variable, reference);
+* Checks whether or not a given variable is a variable declaration in an upper function scope.
+* @param {escope.Variable} variable - A variable to check.
+* @param {escope.Reference} reference - A reference to check.
+* @returns {boolean} `true` if the variable is a variable declaration.
+*/
+function isOuterVariable(variable, reference) {
+    return (
+        variable.defs[0].type === "Variable" &&
+        variable.scope.variableScope !== reference.from.variableScope
+    );
 }
 
 /**
@@ -155,7 +152,8 @@ module.exports = {
                         type: "object",
                         properties: {
                             functions: { type: "boolean" },
-                            classes: { type: "boolean" }
+                            classes: { type: "boolean" },
+                            variables: { type: "boolean" }
                         },
                         additionalProperties: false
                     }
@@ -167,17 +165,23 @@ module.exports = {
     create(context) {
         const options = parseOptions(context.options[0]);
 
-        // Defines a function which checks whether or not a reference is allowed according to the option.
-        let isAllowed;
-
-        if (options.functions && options.classes) {
-            isAllowed = alwaysFalse;
-        } else if (options.functions) {
-            isAllowed = isOuterClass;
-        } else if (options.classes) {
-            isAllowed = isFunction;
-        } else {
-            isAllowed = isFunctionOrOuterClass;
+        /**
+         * Determines whether a given use-before-define case should be reportedaccording to the options.
+         * @param {escope.Variable} variable The variable that gets used before being defined
+         * @param {escope.Reference} reference The reference to the variable
+         * @returns {boolean} `true` if the usage should be reported
+         */
+        function isForbidden(variable, reference) {
+            if (isFunction(variable)) {
+                return options.functions;
+            }
+            if (isOuterClass(variable, reference)) {
+                return options.classes;
+            }
+            if (isOuterVariable(variable, reference)) {
+                return options.variables;
+            }
+            return true;
         }
 
         /**
@@ -200,7 +204,7 @@ module.exports = {
                     !variable ||
                     variable.identifiers.length === 0 ||
                     (variable.identifiers[0].range[1] < reference.identifier.range[1] && !isInInitializer(variable, reference)) ||
-                    isAllowed(variable, reference)
+                    !isForbidden(variable, reference)
                 ) {
                     return;
                 }

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

@@ -4,6 +4,12 @@
  */
 "use strict";
 
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("../ast-utils");
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -34,15 +40,14 @@ module.exports = {
                 const key = node.key,
                     nodeType = typeof key.value;
 
-                if (key.type === "Literal" && (nodeType === "string" || nodeType === "number")) {
+                if (key.type === "Literal" && (nodeType === "string" || nodeType === "number") && key.value !== "__proto__") {
                     context.report({
                         node,
                         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);
 }
 
 /**
@@ -213,7 +207,7 @@ module.exports = {
                 scopeInfo = {
                     upper: scopeInfo,
                     uselessReturns: [],
-                    codePath,
+                    codePath
                 };
             },
 
@@ -226,7 +220,7 @@ module.exports = {
                         message: "Unnecessary return statement.",
                         fix(fixer) {
                             return isRemovable(node) ? fixer.remove(node) : null;
-                        },
+                        }
                     });
                 }
 
@@ -238,7 +232,7 @@ module.exports = {
             onCodePathSegmentStart(segment) {
                 const info = {
                     uselessReturns: getUselessReturns([], segment.allPrevSegments),
-                    returned: false,
+                    returned: false
                 };
 
                 // Stores the info.
@@ -287,7 +281,7 @@ module.exports = {
             WithStatement: markReturnStatementsOnCurrentSegmentsAsUsed,
             ExportNamedDeclaration: markReturnStatementsOnCurrentSegmentsAsUsed,
             ExportDefaultDeclaration: markReturnStatementsOnCurrentSegmentsAsUsed,
-            ExportAllDeclaration: markReturnStatementsOnCurrentSegmentsAsUsed,
+            ExportAllDeclaration: markReturnStatementsOnCurrentSegmentsAsUsed
         };
     }
 };

package/lib/rules/no-var.js

@@ -128,6 +128,43 @@ function isUsedFromOutsideOf(scopeNode) {
     };
 }
 
+/**
+ * Creates the predicate function which checks whether a variable has their references in TDZ.
+ *
+ * The predicate function would return `true`:
+ *
+ * - if a reference is before the declarator. E.g. (var a = b, b = 1;)(var {a = b, b} = {};)
+ * - if a reference is in the expression of their default value.  E.g. (var {a = a} = {};)
+ * - if a reference is in the expression of their initializer.  E.g. (var a = a;)
+ *
+ * @param {ASTNode} node - The initializer node of VariableDeclarator.
+ * @returns {Function} The predicate function.
+ * @private
+ */
+function hasReferenceInTDZ(node) {
+    const initStart = node.range[0];
+    const initEnd = node.range[1];
+
+    return variable => {
+        const id = variable.defs[0].name;
+        const idStart = id.range[0];
+        const defaultValue = (id.parent.type === "AssignmentPattern" ? id.parent.right : null);
+        const defaultStart = defaultValue && defaultValue.range[0];
+        const defaultEnd = defaultValue && defaultValue.range[1];
+
+        return variable.references.some(reference => {
+            const start = reference.identifier.range[0];
+            const end = reference.identifier.range[1];
+
+            return !reference.init && (
+                start < idStart ||
+                (defaultValue !== null && start >= defaultStart && end <= defaultEnd) ||
+                (start >= initStart && end <= initEnd)
+            );
+        });
+    };
+}
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -147,6 +184,21 @@ module.exports = {
     create(context) {
         const sourceCode = context.getSourceCode();
 
+        /**
+         * Checks whether the variables which are defined by the given declarator node have their references in TDZ.
+         *
+         * @param {ASTNode} declarator - The VariableDeclarator node to check.
+         * @returns {boolean} `true` if one of the variables which are defined by the given declarator node have their references in TDZ.
+         */
+        function hasSelfReferenceInTDZ(declarator) {
+            if (!declarator.init) {
+                return false;
+            }
+            const variables = context.getDeclaredVariables(declarator);
+
+            return variables.some(hasReferenceInTDZ(declarator.init));
+        }
+
         /**
          * Checks whether it can fix a given variable declaration or not.
          * It cannot fix if the following cases:
@@ -156,6 +208,8 @@ module.exports = {
          * - A variable is used from outside the scope.
          * - A variable is used from a closure within a loop.
          * - A variable might be used before it is assigned within a loop.
+         * - A variable might be used in TDZ.
+         * - A variable is declared in statement position (e.g. a single-line `IfStatement`)
          *
          * ## A variable is declared on a SwitchCase node.
          *
@@ -201,8 +255,10 @@ module.exports = {
             const scopeNode = getScopeNode(node);
 
             if (node.parent.type === "SwitchCase" ||
-                    variables.some(isRedeclared) ||
-                    variables.some(isUsedFromOutsideOf(scopeNode))) {
+                node.declarations.some(hasSelfReferenceInTDZ) ||
+                variables.some(isRedeclared) ||
+                variables.some(isUsedFromOutsideOf(scopeNode))
+            ) {
                 return false;
             }
 
@@ -215,6 +271,16 @@ module.exports = {
                 }
             }
 
+            if (
+                !isLoopAssignee(node) &&
+                !(node.parent.type === "ForStatement" && node.parent.init === node) &&
+                !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.
+                return false;
+            }
+
             return true;
         }
 
@@ -241,7 +307,7 @@ module.exports = {
         }
 
         return {
-            VariableDeclaration(node) {
+            "VariableDeclaration:exit"(node) {
                 if (node.kind === "var") {
                     report(node);
                 }