eslint 4.18.0 → 4.19.1

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

@@ -217,8 +217,6 @@ module.exports = {
          */
         function checkIfWithoutElse(node) {
             const parent = node.parent;
-            let consequents,
-                alternate;
 
             /*
              * Fixing this would require splitting one statement into two, so no error should
@@ -228,12 +226,15 @@ module.exports = {
                 return;
             }
 
-            for (consequents = []; node.type === "IfStatement"; node = node.alternate) {
-                if (!node.alternate) {
+            const consequents = [];
+            let alternate;
+
+            for (let currentNode = node; currentNode.type === "IfStatement"; currentNode = currentNode.alternate) {
+                if (!currentNode.alternate) {
                     return;
                 }
-                consequents.push(node.consequent);
-                alternate = node.alternate;
+                consequents.push(currentNode.consequent);
+                alternate = currentNode.alternate;
             }
 
             if (consequents.every(alwaysReturns)) {

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

@@ -21,7 +21,7 @@
  * 4. `[gimuy]*`: optional regexp flags
  * 5. `$`: fix the match at the end of the string
  */
-const regex = /^\/([^\\[]|\\.|\[([^\\\]]|\\.)+])*\/[gimuy]*$/;
+const regex = /^\/([^\\[]|\\.|\[([^\\\]]|\\.)+])*\/[gimuys]*$/;
 
 //------------------------------------------------------------------------------
 // Rule Definition

package/lib/rules/no-eval.js

@@ -151,18 +151,17 @@ module.exports = {
          * @returns {void}
          */
         function report(node) {
-            let locationNode = node;
             const parent = node.parent;
+            const locationNode = node.type === "MemberExpression"
+                ? node.property
+                : node;
 
-            if (node.type === "MemberExpression") {
-                locationNode = node.property;
-            }
-            if (parent.type === "CallExpression" && parent.callee === node) {
-                node = parent;
-            }
+            const reportNode = parent.type === "CallExpression" && parent.callee === node
+                ? parent
+                : node;
 
             context.report({
-                node,
+                node: reportNode,
                 loc: locationNode.loc.start,
                 messageId: "unexpected"
             });

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

@@ -167,12 +167,13 @@ module.exports = {
          * @private
          */
         function isInReturnStatement(node) {
-            while (node) {
-                if (node.type === "ReturnStatement" ||
-                        (node.type === "ArrowFunctionExpression" && node.body.type !== "BlockStatement")) {
+            for (let currentNode = node; currentNode; currentNode = currentNode.parent) {
+                if (
+                    currentNode.type === "ReturnStatement" ||
+                    (currentNode.type === "ArrowFunctionExpression" && currentNode.body.type !== "BlockStatement")
+                ) {
                     return true;
                 }
-                node = node.parent;
             }
 
             return false;

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

@@ -20,7 +20,6 @@ const ALLOWABLE_OPERATORS = ["~", "!!", "+", "*"];
  * @returns {Object} The parsed and normalized option object.
  */
 function parseOptions(options) {
-    options = options || {};
     return {
         boolean: "boolean" in options ? Boolean(options.boolean) : true,
         number: "number" in options ? Boolean(options.number) : true,
@@ -186,7 +185,7 @@ module.exports = {
     },
 
     create(context) {
-        const options = parseOptions(context.options[0]);
+        const options = parseOptions(context.options[0] || {});
         const sourceCode = context.getSourceCode();
 
         /**
@@ -197,8 +196,6 @@ module.exports = {
          * @returns {void}
          */
         function report(node, recommendation, shouldFix) {
-            shouldFix = typeof shouldFix === "undefined" ? true : shouldFix;
-
             context.report({
                 node,
                 message: "use `{{recommendation}}` instead.",
@@ -233,7 +230,7 @@ module.exports = {
                 if (!operatorAllowed && options.boolean && isDoubleLogicalNegating(node)) {
                     const recommendation = `Boolean(${sourceCode.getText(node.argument.argument)})`;
 
-                    report(node, recommendation);
+                    report(node, recommendation, true);
                 }
 
                 // ~foo.indexOf(bar)
@@ -249,7 +246,7 @@ module.exports = {
                 if (!operatorAllowed && options.number && node.operator === "+" && !isNumeric(node.argument)) {
                     const recommendation = `Number(${sourceCode.getText(node.argument)})`;
 
-                    report(node, recommendation);
+                    report(node, recommendation, true);
                 }
             },
 
@@ -264,7 +261,7 @@ module.exports = {
                 if (nonNumericOperand) {
                     const recommendation = `Number(${sourceCode.getText(nonNumericOperand)})`;
 
-                    report(node, recommendation);
+                    report(node, recommendation, true);
                 }
 
                 // "" + foo
@@ -272,7 +269,7 @@ module.exports = {
                 if (!operatorAllowed && options.string && isConcatWithEmptyString(node)) {
                     const recommendation = `String(${sourceCode.getText(getNonEmptyOperand(node))})`;
 
-                    report(node, recommendation);
+                    report(node, recommendation, true);
                 }
             },
 
@@ -285,7 +282,7 @@ module.exports = {
                     const code = sourceCode.getText(getNonEmptyOperand(node));
                     const recommendation = `${code} = String(${code})`;
 
-                    report(node, recommendation);
+                    report(node, recommendation, true);
                 }
             }
         };

package/lib/rules/no-invalid-regexp.js

@@ -8,7 +8,10 @@
 // Requirements
 //------------------------------------------------------------------------------
 
-const espree = require("espree");
+const RegExpValidator = require("regexpp").RegExpValidator;
+const validator = new RegExpValidator({ ecmaVersion: 2018 });
+const validFlags = /[gimuys]/g;
+const undefined1 = void 0;
 
 //------------------------------------------------------------------------------
 // Rule Definition
@@ -40,10 +43,14 @@ module.exports = {
     create(context) {
 
         const options = context.options[0];
-        let allowedFlags = "";
+        let allowedFlags = null;
 
         if (options && options.allowConstructorFlags) {
-            allowedFlags = options.allowConstructorFlags.join("");
+            const temp = options.allowConstructorFlags.join("").replace(validFlags, "");
+
+            if (temp) {
+                allowedFlags = new RegExp(`[${temp}]`, "gi");
+            }
         }
 
         /**
@@ -57,51 +64,61 @@ module.exports = {
         }
 
         /**
-         * Validate strings passed to the RegExp constructor
-         * @param {ASTNode} node node to evaluate
-         * @returns {void}
-         * @private
+         * Check syntax error in a given pattern.
+         * @param {string} pattern The RegExp pattern to validate.
+         * @param {boolean} uFlag The Unicode flag.
+         * @returns {string|null} The syntax error.
+         */
+        function validateRegExpPattern(pattern, uFlag) {
+            try {
+                validator.validatePattern(pattern, undefined1, undefined1, uFlag);
+                return null;
+            } catch (err) {
+                return err.message;
+            }
+        }
+
+        /**
+         * Check syntax error in a given flags.
+         * @param {string} flags The RegExp flags to validate.
+         * @returns {string|null} The syntax error.
          */
-        function check(node) {
-            if (node.callee.type === "Identifier" && node.callee.name === "RegExp" && isString(node.arguments[0])) {
+        function validateRegExpFlags(flags) {
+            try {
+                validator.validateFlags(flags);
+                return null;
+            } catch (err) {
+                return `Invalid flags supplied to RegExp constructor '${flags}'`;
+            }
+        }
+
+        return {
+            "CallExpression, NewExpression"(node) {
+                if (node.callee.type !== "Identifier" || node.callee.name !== "RegExp" || !isString(node.arguments[0])) {
+                    return;
+                }
+                const pattern = node.arguments[0].value;
                 let flags = isString(node.arguments[1]) ? node.arguments[1].value : "";
 
                 if (allowedFlags) {
-                    flags = flags.replace(new RegExp(`[${allowedFlags}]`, "gi"), "");
+                    flags = flags.replace(allowedFlags, "");
                 }
 
-                try {
-                    void new RegExp(node.arguments[0].value);
-                } catch (e) {
+                // If flags are unknown, check both are errored or not.
+                const message = validateRegExpFlags(flags) || (
+                    flags
+                        ? validateRegExpPattern(pattern, flags.indexOf("u") !== -1)
+                        : validateRegExpPattern(pattern, true) && validateRegExpPattern(pattern, false)
+                );
+
+                if (message) {
                     context.report({
                         node,
                         message: "{{message}}.",
-                        data: e
+                        data: { message }
                     });
                 }
-
-                if (flags) {
-
-                    try {
-                        espree.parse(`/./${flags}`, context.parserOptions);
-                    } catch (ex) {
-                        context.report({
-                            node,
-                            message: "Invalid flags supplied to RegExp constructor '{{flags}}'.",
-                            data: {
-                                flags
-                            }
-                        });
-                    }
-                }
-
             }
-        }
-
-        return {
-            CallExpression: check,
-            NewExpression: check
         };
-
     }
 };

package/lib/rules/no-irregular-whitespace.js

@@ -101,7 +101,7 @@ module.exports = {
          */
         function removeInvalidNodeErrorsInIdentifierOrLiteral(node) {
             const shouldCheckStrings = skipStrings && (typeof node.value === "string");
-            const shouldCheckRegExps = skipRegExps && (node.value instanceof RegExp);
+            const shouldCheckRegExps = skipRegExps && Boolean(node.regex);
 
             if (shouldCheckStrings || shouldCheckRegExps) {
 

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

@@ -20,9 +20,9 @@
  *      `null`.
  */
 function getContainingLoopNode(node) {
-    let parent = node.parent;
+    for (let currentNode = node; currentNode.parent; currentNode = currentNode.parent) {
+        const parent = currentNode.parent;
 
-    while (parent) {
         switch (parent.type) {
             case "WhileStatement":
             case "DoWhileStatement":
@@ -31,7 +31,7 @@ function getContainingLoopNode(node) {
             case "ForStatement":
 
                 // `init` is outside of the loop.
-                if (parent.init !== node) {
+                if (parent.init !== currentNode) {
                     return parent;
                 }
                 break;
@@ -40,7 +40,7 @@ function getContainingLoopNode(node) {
             case "ForOfStatement":
 
                 // `right` is outside of the loop.
-                if (parent.right !== node) {
+                if (parent.right !== currentNode) {
                     return parent;
                 }
                 break;
@@ -55,9 +55,6 @@ function getContainingLoopNode(node) {
             default:
                 break;
         }
-
-        node = parent;
-        parent = node.parent;
     }
 
     return null;
@@ -73,12 +70,13 @@ function getContainingLoopNode(node) {
  * @returns {ASTNode} The most outer loop node.
  */
 function getTopLoopNode(node, excludedNode) {
-    let retv = node;
     const border = excludedNode ? excludedNode.range[1] : 0;
+    let retv = node;
+    let containingLoopNode = node;
 
-    while (node && node.range[0] >= border) {
-        retv = node;
-        node = getContainingLoopNode(node);
+    while (containingLoopNode && containingLoopNode.range[0] >= border) {
+        retv = containingLoopNode;
+        containingLoopNode = getContainingLoopNode(containingLoopNode);
     }
 
     return retv;

package/lib/rules/no-magic-numbers.js

@@ -101,25 +101,32 @@ module.exports = {
 
         return {
             Literal(node) {
-                let parent = node.parent,
-                    value = node.value,
-                    raw = node.raw;
                 const okTypes = detectObjects ? [] : ["ObjectExpression", "Property", "AssignmentExpression"];
 
                 if (!isNumber(node)) {
                     return;
                 }
 
+                let fullNumberNode;
+                let parent;
+                let value;
+                let raw;
+
                 // For negative magic numbers: update the value and parent node
-                if (parent.type === "UnaryExpression" && parent.operator === "-") {
-                    node = parent;
+                if (node.parent.type === "UnaryExpression" && node.parent.operator === "-") {
+                    fullNumberNode = node.parent;
+                    parent = fullNumberNode.parent;
+                    value = -node.value;
+                    raw = `-${node.raw}`;
+                } else {
+                    fullNumberNode = node;
                     parent = node.parent;
-                    value = -value;
-                    raw = `-${raw}`;
+                    value = node.value;
+                    raw = node.raw;
                 }
 
                 if (shouldIgnoreNumber(value) ||
-                    shouldIgnoreParseInt(parent, node) ||
+                    shouldIgnoreParseInt(parent, fullNumberNode) ||
                     shouldIgnoreArrayIndexes(parent) ||
                     shouldIgnoreJSXNumbers(parent)) {
                     return;
@@ -128,7 +135,7 @@ module.exports = {
                 if (parent.type === "VariableDeclarator") {
                     if (enforceConst && parent.parent.kind !== "const") {
                         context.report({
-                            node,
+                            node: fullNumberNode,
                             message: "Number constants declarations must use 'const'."
                         });
                     }
@@ -137,7 +144,7 @@ module.exports = {
                     (parent.type === "AssignmentExpression" && parent.left.type === "Identifier")
                 ) {
                     context.report({
-                        node,
+                        node: fullNumberNode,
                         message: "No magic number: {{raw}}.",
                         data: {
                             raw

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

@@ -46,11 +46,12 @@ module.exports = {
                     return;
                 }
 
-                let parent = node.parent;
+                let currentChild = node;
+                let parent = currentChild.parent;
 
                 // Find ReturnStatement or ArrowFunctionExpression in ancestors.
                 while (parent && !SENTINEL_TYPE.test(parent.type)) {
-                    node = parent;
+                    currentChild = parent;
                     parent = parent.parent;
                 }
 
@@ -60,7 +61,7 @@ module.exports = {
                         node: parent,
                         message: "Return statement should not contain assignment."
                     });
-                } else if (parent && parent.type === "ArrowFunctionExpression" && parent.body === node) {
+                } else if (parent && parent.type === "ArrowFunctionExpression" && parent.body === currentChild) {
                     context.report({
                         node: parent,
                         message: "Arrow function should not return assignment."

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

@@ -33,7 +33,7 @@ module.exports = {
         const TAGGED_TEMPLATE_MESSAGE = "Unexpected newline between template tag and template literal.";
         const DIVISION_MESSAGE = "Unexpected newline between numerator and division operator.";
 
-        const REGEX_FLAG_MATCHER = /^[gimuy]+$/;
+        const REGEX_FLAG_MATCHER = /^[gimsuy]+$/;
 
         const sourceCode = context.getSourceCode();
 

package/lib/rules/no-unsafe-finally.js

@@ -60,17 +60,20 @@ module.exports = {
                 sentinelNodeType = SENTINEL_NODE_TYPE_RETURN_THROW;
             }
 
-            while (node && !sentinelNodeType.test(node.type)) {
-                if (node.parent.label && label && (node.parent.label.name === label.name)) {
+            for (
+                let currentNode = node;
+                currentNode && !sentinelNodeType.test(currentNode.type);
+                currentNode = currentNode.parent
+            ) {
+                if (currentNode.parent.label && label && (currentNode.parent.label.name === label.name)) {
                     labelInside = true;
                 }
-                if (isFinallyBlock(node)) {
+                if (isFinallyBlock(currentNode)) {
                     if (label && labelInside) {
                         return false;
                     }
                     return true;
                 }
-                node = node.parent;
             }
             return false;
         }

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

@@ -25,8 +25,8 @@ function union(setA, setB) {
 }
 
 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"));
+const REGEX_GENERAL_ESCAPES = new Set("\\bcdDfnpPrsStvwWxu0123456789]");
+const REGEX_NON_CHARCLASS_ESCAPES = union(REGEX_GENERAL_ESCAPES, new Set("^/.$*+?[{}|()Bk"));
 
 /**
  * Parses a regular expression into a list of characters with character class info.

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

@@ -56,12 +56,14 @@ function isRemovable(node) {
  * @returns {boolean} `true` if the node is in a `finally` block.
  */
 function isInFinally(node) {
-    while (node && node.parent && !astUtils.isFunction(node)) {
-        if (node.parent.type === "TryStatement" && node.parent.finalizer === node) {
+    for (
+        let currentNode = node;
+        currentNode && currentNode.parent && !astUtils.isFunction(currentNode);
+        currentNode = currentNode.parent
+    ) {
+        if (currentNode.parent.type === "TryStatement" && currentNode.parent.finalizer === currentNode) {
             return true;
         }
-
-        node = node.parent;
     }
 
     return false;
@@ -116,13 +118,12 @@ module.exports = {
          *
          * @param {ASTNode[]} uselessReturns - The collected return statements.
          * @param {CodePathSegment[]} prevSegments - The previous segments to traverse.
-         * @param {WeakSet<CodePathSegment>} [traversedSegments] A set of segments that have already been traversed in this call
+         * @param {WeakSet<CodePathSegment>} [providedTraversedSegments] A set of segments that have already been traversed in this call
          * @returns {ASTNode[]} `uselessReturns`.
          */
-        function getUselessReturns(uselessReturns, prevSegments, traversedSegments) {
-            if (!traversedSegments) {
-                traversedSegments = new WeakSet();
-            }
+        function getUselessReturns(uselessReturns, prevSegments, providedTraversedSegments) {
+            const traversedSegments = providedTraversedSegments || new WeakSet();
+
             for (const segment of prevSegments) {
                 if (!segment.reachable) {
                     if (!traversedSegments.has(segment)) {

package/lib/rules/no-var.js

@@ -33,10 +33,12 @@ function isGlobal(variable) {
  *      scope.
  */
 function getEnclosingFunctionScope(scope) {
-    while (scope.type !== "function" && scope.type !== "global") {
-        scope = scope.upper;
+    let currentScope = scope;
+
+    while (currentScope.type !== "function" && currentScope.type !== "global") {
+        currentScope = currentScope.upper;
     }
-    return scope;
+    return currentScope;
 }
 
 /**
@@ -87,12 +89,10 @@ const SCOPE_NODE_TYPE = /^(?:Program|BlockStatement|SwitchStatement|ForStatement
  *      `ForOfStatement`.
  */
 function getScopeNode(node) {
-    while (node) {
-        if (SCOPE_NODE_TYPE.test(node.type)) {
-            return node;
+    for (let currentNode = node; currentNode; currentNode = currentNode.parent) {
+        if (SCOPE_NODE_TYPE.test(currentNode.type)) {
+            return currentNode;
         }
-
-        node = node.parent;
     }
 
     /* istanbul ignore next : unreachable */

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

@@ -116,7 +116,8 @@ function areLineBreaksRequired(node, options, first, last) {
     } else {
 
         // is ImportDeclaration or ExportNamedDeclaration
-        objectProperties = node.specifiers;
+        objectProperties = node.specifiers
+            .filter(s => s.type === "ImportSpecifier" || s.type === "ExportSpecifier");
     }
 
     return objectProperties.length >= options.minProperties ||