eslint 3.15.0 → 3.17.1

package/lib/rules/no-undefined.js

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

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

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

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

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

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

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

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

@@ -62,9 +62,11 @@ 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.";
+        const REST_PROPERTY_TYPE = /^(?:Experimental)?RestProperty$/;
 
         const config = {
             vars: "all",
@@ -138,17 +140,16 @@ module.exports = {
          */
         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 variable.defs.some(def => {
+                    const propertyNode = def.name.parent;
+                    const patternNode = propertyNode.parent;
+
+                    return (
+                        propertyNode.type === "Property" &&
+                        patternNode.type === "ObjectPattern" &&
+                        REST_PROPERTY_TYPE.test(patternNode.properties[patternNode.properties.length - 1].type)
+                    );
+                });
             }
 
             return false;
@@ -566,23 +567,8 @@ module.exports = {
          */
         function getLocation(variable) {
             const comment = variable.eslintExplicitGlobalComment;
-            const baseLoc = comment.loc.start;
-            let column = getColumnInComment(variable, comment);
-            const prefix = comment.value.slice(0, column);
-            const lineInComment = (prefix.match(/\n/g) || []).length;
 
-            if (lineInComment > 0) {
-                column -= 1 + prefix.lastIndexOf("\n");
-            } else {
-
-                // 2 is for `/*`
-                column += baseLoc.column + 2;
-            }
-
-            return {
-                line: baseLoc.line + lineInComment,
-                column
-            };
+            return sourceCode.getLocFromIndex(comment.range[0] + 2 + getColumnInComment(variable, comment));
         }
 
         //--------------------------------------------------------------------------

package/lib/rules/no-use-before-define.js

@@ -166,7 +166,7 @@ module.exports = {
         const options = parseOptions(context.options[0]);
 
         /**
-         * Determines whether a given use-before-define case should be reportedaccording to the options.
+         * Determines whether a given use-before-define case should be reported according 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

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

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

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

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

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

@@ -24,7 +24,7 @@ function union(setA, setB) {
     }());
 }
 
-const VALID_STRING_ESCAPES = new Set("\\nrvtbfux\n\r\u2028\u2029");
+const VALID_STRING_ESCAPES = union(new Set("\\nrvtbfux"), astUtils.LINEBREAKS);
 const REGEX_GENERAL_ESCAPES = new Set("\\bcdDfnrsStvwWxu0123456789]");
 const REGEX_NON_CHARCLASS_ESCAPES = union(REGEX_GENERAL_ESCAPES, new Set("^/.$*+?[{}|()B"));
 
@@ -94,7 +94,7 @@ module.exports = {
         function report(node, startOffset, character) {
             context.report({
                 node,
-                loc: astUtils.getLocationFromRangeIndex(sourceCode, astUtils.getRangeIndexFromLocation(sourceCode, node.loc.start) + startOffset),
+                loc: sourceCode.getLocFromIndex(sourceCode.getIndexFromLoc(node.loc.start) + startOffset),
                 message: "Unnecessary escape character: \\{{character}}.",
                 data: { character }
             });

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

@@ -8,7 +8,8 @@
 // Requirements
 //------------------------------------------------------------------------------
 
-const astUtils = require("../ast-utils");
+const astUtils = require("../ast-utils"),
+    FixTracker = require("../util/fix-tracker");
 
 //------------------------------------------------------------------------------
 // Helpers
@@ -45,13 +46,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);
 }
 
 /**
@@ -225,7 +220,17 @@ module.exports = {
                         loc: node.loc,
                         message: "Unnecessary return statement.",
                         fix(fixer) {
-                            return isRemovable(node) ? fixer.remove(node) : null;
+                            if (isRemovable(node)) {
+
+                                // Extend the replacement range to include the
+                                // entire function to avoid conflicting with
+                                // no-else-return.
+                                // https://github.com/eslint/eslint/issues/8026
+                                return new FixTracker(fixer, context.getSourceCode())
+                                    .retainEnclosingFunction(node)
+                                    .remove(node);
+                            }
+                            return null;
                         }
                     });
                 }

package/lib/rules/no-var.js

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

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

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

package/lib/rules/nonblock-statement-body-position.js

@@ -0,0 +1,114 @@
+/**
+ * @fileoverview enforce the location of single-line statements
+ * @author Teddy Katz
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+const POSITION_SCHEMA = { enum: ["beside", "below", "any"] };
+
+module.exports = {
+    meta: {
+        docs: {
+            description: "enforce the location of single-line statements",
+            category: "Stylistic Issues",
+            recommended: false
+        },
+        fixable: "whitespace",
+        schema: [
+            POSITION_SCHEMA,
+            {
+                properties: {
+                    overrides: {
+                        properties: {
+                            if: POSITION_SCHEMA,
+                            else: POSITION_SCHEMA,
+                            while: POSITION_SCHEMA,
+                            do: POSITION_SCHEMA,
+                            for: POSITION_SCHEMA
+                        },
+                        additionalProperties: false
+                    }
+                },
+                additionalProperties: false
+            }
+        ]
+    },
+
+    create(context) {
+        const sourceCode = context.getSourceCode();
+
+        //----------------------------------------------------------------------
+        // Helpers
+        //----------------------------------------------------------------------
+
+        /**
+         * Gets the applicable preference for a particular keyword
+         * @param {string} keywordName The name of a keyword, e.g. 'if'
+         * @returns {string} The applicable option for the keyword, e.g. 'beside'
+         */
+        function getOption(keywordName) {
+            return context.options[1] && context.options[1].overrides && context.options[1].overrides[keywordName] ||
+                context.options[0] ||
+                "beside";
+        }
+
+        /**
+         * Validates the location of a single-line statement
+         * @param {ASTNode} node The single-line statement
+         * @param {string} keywordName The applicable keyword name for the single-line statement
+         * @returns {void}
+         */
+        function validateStatement(node, keywordName) {
+            const option = getOption(keywordName);
+
+            if (node.type === "BlockStatement" || option === "any") {
+                return;
+            }
+
+            const tokenBefore = sourceCode.getTokenBefore(node);
+
+            if (tokenBefore.loc.end.line === node.loc.start.line && option === "below") {
+                context.report({
+                    node,
+                    message: "Expected a linebreak before this statement.",
+                    fix: fixer => fixer.insertTextBefore(node, "\n")
+                });
+            } else if (tokenBefore.loc.end.line !== node.loc.start.line && option === "beside") {
+                context.report({
+                    node,
+                    message: "Expected no linebreak before this statement.",
+                    fix(fixer) {
+                        if (sourceCode.getText().slice(tokenBefore.range[1], node.range[0]).trim()) {
+                            return null;
+                        }
+                        return fixer.replaceTextRange([tokenBefore.range[1], node.range[0]], " ");
+                    }
+                });
+            }
+        }
+
+        //----------------------------------------------------------------------
+        // Public
+        //----------------------------------------------------------------------
+
+        return {
+            IfStatement(node) {
+                validateStatement(node.consequent, "if");
+
+                // Check the `else` node, but don't check 'else if' statements.
+                if (node.alternate && node.alternate.type !== "IfStatement") {
+                    validateStatement(node.alternate, "else");
+                }
+            },
+            WhileStatement: node => validateStatement(node.body, "while"),
+            DoWhileStatement: node => validateStatement(node.body, "do"),
+            ForStatement: node => validateStatement(node.body, "for"),
+            ForInStatement: node => validateStatement(node.body, "for"),
+            ForOfStatement: node => validateStatement(node.body, "for")
+        };
+    }
+};

package/lib/rules/object-curly-newline.js

@@ -128,8 +128,8 @@ module.exports = {
             const options = normalizedOptions[node.type];
             const openBrace = sourceCode.getFirstToken(node);
             const closeBrace = sourceCode.getLastToken(node);
-            let first = sourceCode.getTokenOrCommentAfter(openBrace);
-            let last = sourceCode.getTokenOrCommentBefore(closeBrace);
+            let first = sourceCode.getTokenAfter(openBrace, { includeComments: true });
+            let last = sourceCode.getTokenBefore(closeBrace, { includeComments: true });
             const needsLinebreaks = (
                 node.properties.length >= options.minProperties ||
                 (

package/lib/rules/object-curly-spacing.js

@@ -206,14 +206,8 @@ module.exports = {
          */
         function getClosingBraceOfObject(node) {
             const lastProperty = node.properties[node.properties.length - 1];
-            let token = sourceCode.getTokenAfter(lastProperty);
 
-            // skip ')' and trailing commas.
-            while (token.type !== "Punctuator" || token.value !== "}") {
-                token = sourceCode.getTokenAfter(token);
-            }
-
-            return token;
+            return sourceCode.getTokenAfter(lastProperty, astUtils.isClosingBraceToken);
         }
 
         /**
@@ -254,15 +248,9 @@ module.exports = {
                 firstSpecifier = node.specifiers[1];
             }
 
-            const first = sourceCode.getTokenBefore(firstSpecifier);
-            let last = sourceCode.getTokenAfter(lastSpecifier);
-
-            // to support a trailing comma.
-            if (last.value === ",") {
-                last = sourceCode.getTokenAfter(last);
-            }
-
-            const second = sourceCode.getTokenAfter(first),
+            const first = sourceCode.getTokenBefore(firstSpecifier),
+                last = sourceCode.getTokenAfter(lastSpecifier, astUtils.isNotCommaToken),
+                second = sourceCode.getTokenAfter(first),
                 penultimate = sourceCode.getTokenBefore(last);
 
             validateBraceSpacing(node, first, second, penultimate, last);
@@ -280,15 +268,9 @@ module.exports = {
 
             const firstSpecifier = node.specifiers[0],
                 lastSpecifier = node.specifiers[node.specifiers.length - 1],
-                first = sourceCode.getTokenBefore(firstSpecifier);
-            let last = sourceCode.getTokenAfter(lastSpecifier);
-
-            // to support a trailing comma.
-            if (last.value === ",") {
-                last = sourceCode.getTokenAfter(last);
-            }
-
-            const second = sourceCode.getTokenAfter(first),
+                first = sourceCode.getTokenBefore(firstSpecifier),
+                last = sourceCode.getTokenAfter(lastSpecifier, astUtils.isNotCommaToken),
+                second = sourceCode.getTokenAfter(first),
                 penultimate = sourceCode.getTokenBefore(last);
 
             validateBraceSpacing(node, first, second, penultimate, last);

package/lib/rules/object-property-newline.js

@@ -34,9 +34,9 @@ module.exports = {
 
     create(context) {
         const allowSameLine = context.options[0] && Boolean(context.options[0].allowMultiplePropertiesPerLine);
-        const errorMessage = allowSameLine ?
-            "Object properties must go on a new line if they aren't all on the same line." :
-            "Object properties must go on a new line.";
+        const errorMessage = allowSameLine
+            ? "Object properties must go on a new line if they aren't all on the same line."
+            : "Object properties must go on a new line.";
 
         const sourceCode = context.getSourceCode();
 

package/lib/rules/object-shorthand.js

@@ -215,8 +215,8 @@ module.exports = {
         * @returns {Object} A fix for this node
         */
         function makeFunctionShorthand(fixer, node) {
-            const firstKeyToken = node.computed ? sourceCode.getTokens(node).find(token => token.value === "[") : sourceCode.getFirstToken(node.key);
-            const lastKeyToken = node.computed ? sourceCode.getTokensBetween(node.key, node.value).find(token => token.value === "]") : sourceCode.getLastToken(node.key);
+            const firstKeyToken = node.computed ? sourceCode.getFirstToken(node, astUtils.isOpeningBracketToken) : sourceCode.getFirstToken(node.key);
+            const lastKeyToken = node.computed ? sourceCode.getFirstTokenBetween(node.key, node.value, astUtils.isClosingBracketToken) : sourceCode.getLastToken(node.key);
             const keyText = sourceCode.text.slice(firstKeyToken.range[0], lastKeyToken.range[1]);
             let keyPrefix = "";
 
@@ -368,11 +368,12 @@ module.exports = {
                 // Checks for property/method shorthand.
                 if (isConciseProperty) {
                     if (node.method && (APPLY_NEVER || AVOID_QUOTES && isStringLiteral(node.key))) {
+                        const message = APPLY_NEVER ? "Expected longform method syntax." : "Expected longform method syntax for string literal keys.";
 
                         // { x() {} } should be written as { x: function() {} }
                         context.report({
                             node,
-                            message: `Expected longform method syntax${APPLY_NEVER ? "" : " for string literal keys"}.`,
+                            message,
                             fix: fixer => makeFunctionLongform(fixer, node)
                         });
                     } else if (APPLY_NEVER) {

package/lib/rules/operator-assignment.js

@@ -108,7 +108,7 @@ module.exports = {
         * @returns {Token} The operator token in the node
         */
         function getOperatorToken(node) {
-            return sourceCode.getTokensBetween(node.left, node.right).find(token => token.value === node.operator);
+            return sourceCode.getFirstTokenBetween(node.left, node.right, token => token.value === node.operator);
         }
 
         /**
@@ -135,7 +135,7 @@ module.exports = {
                                 const equalsToken = getOperatorToken(node);
                                 const operatorToken = getOperatorToken(expr);
                                 const leftText = sourceCode.getText().slice(node.range[0], equalsToken.range[0]);
-                                const rightText = sourceCode.getText().slice(operatorToken.range[1], node.range[1]);
+                                const rightText = sourceCode.getText().slice(operatorToken.range[1], expr.right.range[1]);
 
                                 return fixer.replaceText(node, `${leftText}${expr.operator}=${rightText}`);
                             }