eslint 5.0.1 → 5.1.0

package/CHANGELOG.md

@@ -1,3 +1,26 @@
+v5.1.0 - July 8, 2018
+
+* 7328f99 Build: package.json update for eslint-config-eslint release (ESLint Jenkins)
+* b161f6b Build: Include prerelease install info in release blog post (#10463) (Kevin Partington)
+* b2df738 Fix: prefer-object-spread duplicated comma (fixes #10512, fixes #10532) (#10524) (Toru Nagashima)
+* d8c3a25 Fix: wrap-regex doesn't work in some expression(fixes #10573) (#10576) (薛定谔的猫)
+* 114f42e Docs: Clarify option defaults in max-lines-per-function docs (#10569) (Chris Harwood)
+* 63f36f7 Fix: sort-keys in an object that contains spread (fixes #10261) (#10495) (katerberg)
+* 601a5c4 Fix: Prefer-const rule crashing on array destructuring (fixes #10520) (#10527) (Michael Mason)
+* 143890a Update: Adjust grammar of error/warnings fixable (#10546) (Matt Mischuk)
+* 8ee39c5 Chore: small refactor config-validator (#10565) (薛定谔的猫)
+* 100f1be Docs: add note about release issues to readme (#10572) (Teddy Katz)
+* 02efeac Fix: do not fail on nested unknown operators (#10561) (Rubén Norte)
+* 92b19ca Chore: use eslintrc overrides(dogfooding) (#10566) (薛定谔的猫)
+* 076a6b6 Docs: add actionable fix to no-irregular-whitespace (#10558) (Matteo Collina)
+* de663ec Docs: Only successfully linted files are cached (fixes #9802) (#10557) (Kevin Partington)
+* f0e22fc Upgrade: globals@11.7.0 (#10497) (薛定谔的猫)
+* 8a2ff2c Docs:  adding a section about disable rules for some files (#10536) (Wellington Soares)
+* f22a3f8 Docs: fix a word in no-implied-eval (#10539) (Dan Homola)
+* 20d8bbd Docs: add missing paragraph about "custom parsers" (#10547) (Pig Fang)
+* b7addf6 Update: deprecate no-catch-shadow (fixes #10466) (#10526) (Toru Nagashima)
+* e862dc3 Fix: Remove autofixer for no-debugger (fixes #10242) (#10509) (Teddy Katz)
+
 v5.0.1 - June 25, 2018
 
 * 196c102 Fix: valid-jsdoc should allow optional returns for async (fixes #10386) (#10480) (Mark Banner)

package/README.md

@@ -157,7 +157,7 @@ Join our [Mailing List](https://groups.google.com/group/eslint) or [Chatroom](ht
 
 ## Releases
 
-We have scheduled releases every two weeks on Friday or Saturday.
+We have scheduled releases every two weeks on Friday or Saturday. You can follow a [release issue](https://github.com/eslint/eslint/issues?q=is%3Aopen+is%3Aissue+label%3Arelease) for updates about the scheduling of any particular release.
 
 ## Semantic Versioning Policy
 

package/lib/code-path-analysis/code-path-analyzer.js

@@ -60,7 +60,7 @@ function isForkingByTrueOrFalse(node) {
             return parent.test === node;
 
         case "LogicalExpression":
-            return true;
+            return isHandledLogicalOperator(parent.operator);
 
         default:
             return false;

package/lib/config/config-validator.js

@@ -23,10 +23,15 @@ const ruleValidators = new WeakMap();
 let validateSchema;
 
 // Defitions for deprecation warnings.
-const deprecationWarningMessages = Object.freeze({
+const deprecationWarningMessages = {
     ESLINT_LEGACY_ECMAFEATURES: "The 'ecmaFeatures' config file property is deprecated, and has no effect.",
     ESLINT_LEGACY_OBJECT_REST_SPREAD: "The 'parserOptions.ecmaFeatures.experimentalObjectRestSpread' option is deprecated. Use 'parserOptions.ecmaVersion' instead."
-});
+};
+const severityMap = {
+    error: 2,
+    warn: 1,
+    off: 0
+};
 
 /**
  * Gets a complete options schema for a rule.
@@ -65,12 +70,14 @@ function getRuleOptionsSchema(rule) {
  */
 function validateRuleSeverity(options) {
     const severity = Array.isArray(options) ? options[0] : options;
+    const normSeverity = typeof severity === "string" ? severityMap[severity.toLowerCase()] : severity;
 
-    if (severity !== 0 && severity !== 1 && severity !== 2 && !(typeof severity === "string" && /^(?:off|warn|error)$/i.test(severity))) {
-        throw new Error(`\tSeverity should be one of the following: 0 = off, 1 = warn, 2 = error (you passed '${util.inspect(severity).replace(/'/g, "\"").replace(/\n/g, "")}').\n`);
+    if (normSeverity === 0 || normSeverity === 1 || normSeverity === 2) {
+        return normSeverity;
     }
 
-    return severity;
+    throw new Error(`\tSeverity should be one of the following: 0 = off, 1 = warn, 2 = error (you passed '${util.inspect(severity).replace(/'/g, "\"").replace(/\n/g, "")}').\n`);
+
 }
 
 /**
@@ -116,7 +123,7 @@ function validateRuleOptions(rule, ruleId, options, source) {
     try {
         const severity = validateRuleSeverity(options);
 
-        if (severity !== 0 && !(typeof severity === "string" && severity.toLowerCase() === "off")) {
+        if (severity !== 0) {
             validateRuleSchema(rule, Array.isArray(options) ? options.slice(1) : []);
         }
     } catch (err) {

package/lib/formatters/stylish.js

@@ -89,7 +89,7 @@ module.exports = function(results) {
 
         if (fixableErrorCount > 0 || fixableWarningCount > 0) {
             output += chalk[summaryColor].bold([
-                "  ", fixableErrorCount, pluralize(" error", fixableErrorCount), ", ",
+                "  ", fixableErrorCount, pluralize(" error", fixableErrorCount), " and ",
                 fixableWarningCount, pluralize(" warning", fixableWarningCount),
                 " potentially fixable with the `--fix` option.\n"
             ].join(""));

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

@@ -1,6 +1,7 @@
 /**
  * @fileoverview Rule to flag variable leak in CatchClauses in IE 8 and earlier
  * @author Ian Christian Myers
+ * @deprecated in ESLint v5.1.0
  */
 
 "use strict";
@@ -21,8 +22,10 @@ module.exports = {
             description: "disallow `catch` clause parameters from shadowing variables in the outer scope",
             category: "Variables",
             recommended: false,
-            url: "https://eslint.org/docs/rules/no-catch-shadow"
+            url: "https://eslint.org/docs/rules/no-catch-shadow",
+            replacedBy: ["no-shadow"]
         },
+        deprecated: true,
 
         schema: [],
 

package/lib/rules/no-debugger.js

@@ -5,8 +5,6 @@
 
 "use strict";
 
-const astUtils = require("../ast-utils");
-
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -19,7 +17,7 @@ module.exports = {
             recommended: true,
             url: "https://eslint.org/docs/rules/no-debugger"
         },
-        fixable: "code",
+        fixable: null,
         schema: [],
         messages: {
             unexpected: "Unexpected 'debugger' statement."
@@ -32,13 +30,7 @@ module.exports = {
             DebuggerStatement(node) {
                 context.report({
                     node,
-                    messageId: "unexpected",
-                    fix(fixer) {
-                        if (astUtils.STATEMENT_LIST_PARENTS.has(node.parent.type)) {
-                            return fixer.remove(node);
-                        }
-                        return null;
-                    }
+                    messageId: "unexpected"
                 });
             }
         };

package/lib/rules/prefer-const.js

@@ -170,7 +170,7 @@ function getIdentifierIfShouldBeConst(variable, ignoreReadBeforeAssign) {
                     const elements = leftNode.elements;
 
                     hasOuterVariables = elements
-                        .map(element => element.name)
+                        .map(element => element && element.name)
                         .some(name => isOuterVariableInDestructing(name, variable.scope));
                 }
                 if (hasOuterVariables) {

package/lib/rules/prefer-object-spread.js

@@ -6,21 +6,15 @@
 
 "use strict";
 
-const matchAll = require("string.prototype.matchall");
+const { CALL, ReferenceTracker } = require("eslint-utils");
+const {
+    isCommaToken,
+    isOpeningParenToken,
+    isClosingParenToken,
+    isParenthesised
+} = require("../ast-utils");
 
-/**
- * Helper that checks if the node is an Object.assign call
- * @param {ASTNode} node - The node that the rule warns on
- * @returns {boolean} - Returns true if the node is an Object.assign call
- */
-function isObjectAssign(node) {
-    return (
-        node.callee &&
-        node.callee.type === "MemberExpression" &&
-        node.callee.object.name === "Object" &&
-        node.callee.property.name === "assign"
-    );
-}
+const ANY_SPACE = /\s/;
 
 /**
  * Helper that checks if the Object.assign call has array spread
@@ -35,15 +29,12 @@ function hasArraySpread(node) {
  * Helper that checks if the node needs parentheses to be valid JS.
  * The default is to wrap the node in parentheses to avoid parsing errors.
  * @param {ASTNode} node - The node that the rule warns on
+ * @param {Object} sourceCode - in context sourcecode object
  * @returns {boolean} - Returns true if the node needs parentheses
  */
-function needsParens(node) {
+function needsParens(node, sourceCode) {
     const parent = node.parent;
 
-    if (!parent || !node.type) {
-        return true;
-    }
-
     switch (parent.type) {
         case "VariableDeclarator":
         case "ArrayExpression":
@@ -51,180 +42,168 @@ function needsParens(node) {
         case "CallExpression":
         case "Property":
             return false;
+        case "AssignmentExpression":
+            return parent.left === node && !isParenthesised(sourceCode, node);
         default:
-            return true;
+            return !isParenthesised(sourceCode, node);
     }
 }
 
 /**
  * Determines if an argument needs parentheses. The default is to not add parens.
  * @param {ASTNode} node - The node to be checked.
+ * @param {Object} sourceCode - in context sourcecode object
  * @returns {boolean} True if the node needs parentheses
  */
-function argNeedsParens(node) {
-    if (!node.type) {
-        return false;
-    }
-
+function argNeedsParens(node, sourceCode) {
     switch (node.type) {
         case "AssignmentExpression":
         case "ArrowFunctionExpression":
         case "ConditionalExpression":
-            return true;
+            return !isParenthesised(sourceCode, node);
         default:
             return false;
     }
 }
 
 /**
- * Helper that adds a comma after the last non-whitespace character that is not a part of a comment.
- * @param {string} formattedArg - String of argument text
- * @param {array} comments - comments inside the argument
- * @returns {string} - argument with comma at the end of it
+ * Get the parenthesis tokens of a given ObjectExpression node.
+ * This incldues the braces of the object literal and enclosing parentheses.
+ * @param {ASTNode} node The node to get.
+ * @param {Token} leftArgumentListParen The opening paren token of the argument list.
+ * @param {SourceCode} sourceCode The source code object to get tokens.
+ * @returns {Token[]} The parenthesis tokens of the node. This is sorted by the location.
  */
-function addComma(formattedArg, comments) {
-    const nonWhitespaceCharacterRegex = /[^\s\\]/g;
-    const nonWhitespaceCharacters = Array.from(matchAll(formattedArg, nonWhitespaceCharacterRegex));
-    const commentRanges = comments.map(comment => comment.range);
-    const validWhitespaceMatches = [];
-
-    // Create a list of indexes where non-whitespace characters exist.
-    nonWhitespaceCharacters.forEach(match => {
-        const insertIndex = match.index + match[0].length;
-
-        if (!commentRanges.length) {
-            validWhitespaceMatches.push(insertIndex);
-        }
-
-        // If comment ranges are found make sure that the non whitespace characters are not part of the comment.
-        commentRanges.forEach(arr => {
-            const commentStart = arr[0];
-            const commentEnd = arr[1];
-
-            if (insertIndex < commentStart || insertIndex > commentEnd) {
-                validWhitespaceMatches.push(insertIndex);
-            }
-        });
-    });
-    const insertPos = Math.max(...validWhitespaceMatches);
-    const regex = new RegExp(`^((?:.|[^/s/S]){${insertPos}}) *`);
+function getParenTokens(node, leftArgumentListParen, sourceCode) {
+    const parens = [sourceCode.getFirstToken(node), sourceCode.getLastToken(node)];
+    let leftNext = sourceCode.getTokenBefore(node);
+    let rightNext = sourceCode.getTokenAfter(node);
+
+    // Note: don't include the parens of the argument list.
+    while (
+        leftNext &&
+        rightNext &&
+        leftNext.range[0] > leftArgumentListParen.range[0] &&
+        isOpeningParenToken(leftNext) &&
+        isClosingParenToken(rightNext)
+    ) {
+        parens.push(leftNext, rightNext);
+        leftNext = sourceCode.getTokenBefore(leftNext);
+        rightNext = sourceCode.getTokenAfter(rightNext);
+    }
 
-    return formattedArg.replace(regex, "$1, ");
+    return parens.sort((a, b) => a.range[0] - b.range[0]);
 }
 
 /**
- * Helper formats an argument by either removing curlies or adding a spread operator
- * @param {ASTNode|null} arg - ast node representing argument to format
- * @param {boolean} isLast - true if on the last element of the array
- * @param {Object} sourceCode - in context sourcecode object
- * @param {array} comments - comments inside checked node
- * @returns {string} - formatted argument
+ * Get the range of a given token and around whitespaces.
+ * @param {Token} token The token to get range.
+ * @param {SourceCode} sourceCode The source code object to get tokens.
+ * @returns {number} The end of the range of the token and around whitespaces.
  */
-function formatArg(arg, isLast, sourceCode, comments) {
-    const text = sourceCode.getText(arg);
-    const parens = argNeedsParens(arg);
-    const spread = arg.type === "SpreadElement" ? "" : "...";
-
-    if (arg.type === "ObjectExpression" && arg.properties.length === 0) {
-        return "";
-    }
+function getStartWithSpaces(token, sourceCode) {
+    const text = sourceCode.text;
+    let start = token.range[0];
 
-    if (arg.type === "ObjectExpression") {
+    // If the previous token is a line comment then skip this step to avoid commenting this token out.
+    {
+        const prevToken = sourceCode.getTokenBefore(token, { includeComments: true });
 
-        /**
-         * This regex finds the opening curly brace and any following spaces and replaces it with whatever
-         * exists before the curly brace. It also does the same for the closing curly brace. This is to avoid
-         * having multiple spaces around the object expression depending on how the object properties are spaced.
-         */
-        const formattedObjectLiteral = text.replace(/^(.*){ */, "$1").replace(/ *}([^}]*)$/, "$1");
-
-        return isLast ? formattedObjectLiteral : addComma(formattedObjectLiteral, comments);
+        if (prevToken && prevToken.type === "Line") {
+            return start;
+        }
     }
 
-    if (isLast) {
-        return parens ? `${spread}(${text})` : `${spread}${text}`;
+    // Detect spaces before the token.
+    while (ANY_SPACE.test(text[start - 1] || "")) {
+        start -= 1;
     }
 
-    return parens ? addComma(`${spread}(${text})`, comments) : `${spread}${addComma(text, comments)}`;
+    return start;
 }
 
 /**
- * Autofixes the Object.assign call to use an object spread instead.
- * @param {ASTNode|null} node - The node that the rule warns on, i.e. the Object.assign call
- * @param {string} sourceCode - sourceCode of the Object.assign call
- * @returns {Function} autofixer - replaces the Object.assign with a spread object.
+ * Get the range of a given token and around whitespaces.
+ * @param {Token} token The token to get range.
+ * @param {SourceCode} sourceCode The source code object to get tokens.
+ * @returns {number} The start of the range of the token and around whitespaces.
  */
-function autofixSpread(node, sourceCode) {
-    return fixer => {
-        const args = node.arguments;
-        const firstArg = args[0];
-        const lastArg = args[args.length - 1];
-        const parens = needsParens(node);
-        const comments = sourceCode.getCommentsInside(node);
-        const replaceObjectAssignStart = fixer.replaceTextRange(
-            [node.range[0], firstArg.range[0]],
-            `${parens ? "({" : "{"}`
-        );
+function getEndWithSpaces(token, sourceCode) {
+    const text = sourceCode.text;
+    let end = token.range[1];
 
-        const handleArgs = args
-            .map((arg, i, arr) => formatArg(arg, i + 1 >= arr.length, sourceCode, comments))
-            .filter(arg => arg !== "," && arg !== "");
-
-        const insertBody = fixer.replaceTextRange([firstArg.range[0], lastArg.range[1]], handleArgs.join(""));
-        const replaceObjectAssignEnd = fixer.replaceTextRange([lastArg.range[1], node.range[1]], `${parens ? "})" : "}"}`);
+    // Detect spaces after the token.
+    while (ANY_SPACE.test(text[end] || "")) {
+        end += 1;
+    }
 
-        return [
-            replaceObjectAssignStart,
-            insertBody,
-            replaceObjectAssignEnd
-        ];
-    };
+    return end;
 }
 
 /**
- * Autofixes the Object.assign call with a single object literal as an argument
+ * Autofixes the Object.assign call to use an object spread instead.
  * @param {ASTNode|null} node - The node that the rule warns on, i.e. the Object.assign call
  * @param {string} sourceCode - sourceCode of the Object.assign call
- * @returns {Function} autofixer - replaces the Object.assign with a object literal.
+ * @returns {Function} autofixer - replaces the Object.assign with a spread object.
  */
-function autofixObjectLiteral(node, sourceCode) {
-    return fixer => {
-        const argument = node.arguments[0];
-        const parens = needsParens(node);
+function defineFixer(node, sourceCode) {
+    return function *(fixer) {
+        const leftParen = sourceCode.getTokenAfter(node.callee, isOpeningParenToken);
+        const rightParen = sourceCode.getLastToken(node);
+
+        // Remove the callee `Object.assign`
+        yield fixer.remove(node.callee);
+
+        // Replace the parens of argument list to braces.
+        if (needsParens(node, sourceCode)) {
+            yield fixer.replaceText(leftParen, "({");
+            yield fixer.replaceText(rightParen, "})");
+        } else {
+            yield fixer.replaceText(leftParen, "{");
+            yield fixer.replaceText(rightParen, "}");
+        }
 
-        return fixer.replaceText(node, `${parens ? "(" : ""}${sourceCode.text.slice(argument.range[0], argument.range[1])}${parens ? ")" : ""}`);
-    };
-}
+        // Process arguments.
+        for (const argNode of node.arguments) {
+            const innerParens = getParenTokens(argNode, leftParen, sourceCode);
+            const left = innerParens.shift();
+            const right = innerParens.pop();
 
-/**
- * Check if the node has modified a given variable
- * @param {ASTNode|null} node - The node that the rule warns on, i.e. the Object.assign call
- * @returns {boolean} - true if node is an assignment, variable declaration, or import statement
- */
-function isModifier(node) {
-    if (!node.type) {
-        return false;
-    }
+            if (argNode.type === "ObjectExpression") {
+                const maybeTrailingComma = sourceCode.getLastToken(argNode, 1);
+                const maybeArgumentComma = sourceCode.getTokenAfter(right);
 
-    return node.type === "AssignmentExpression" ||
-        node.type === "VariableDeclarator" ||
-        node.type === "ImportDeclaration";
-}
+                /*
+                 * Make bare this object literal.
+                 * And remove spaces inside of the braces for better formatting.
+                 */
+                for (const innerParen of innerParens) {
+                    yield fixer.remove(innerParen);
+                }
+                yield fixer.removeRange([left.range[0], getEndWithSpaces(left, sourceCode)]);
+                yield fixer.removeRange([getStartWithSpaces(right, sourceCode), right.range[1]]);
 
-/**
- * Check if the node has modified a given variable
- * @param {array} references - list of reference nodes
- * @returns {boolean} - true if node is has been overwritten by an assignment or import
- */
-function modifyingObjectReference(references) {
-    return references.some(ref => (
-        ref.identifier &&
-        ref.identifier.parent &&
-        isModifier(ref.identifier.parent)
-    ));
+                // Remove the comma of this argument if it's duplication.
+                if (
+                    (argNode.properties.length === 0 || isCommaToken(maybeTrailingComma)) &&
+                    isCommaToken(maybeArgumentComma)
+                ) {
+                    yield fixer.remove(maybeArgumentComma);
+                }
+            } else {
+
+                // Make spread.
+                if (argNeedsParens(argNode, sourceCode)) {
+                    yield fixer.insertTextBefore(left, "...(");
+                    yield fixer.insertTextAfter(right, ")");
+                } else {
+                    yield fixer.insertTextBefore(left, "...");
+                }
+            }
+        }
+    };
 }
 
-
 module.exports = {
     meta: {
         docs: {
@@ -242,61 +221,33 @@ module.exports = {
         }
     },
 
-    create: function rule(context) {
+    create(context) {
         const sourceCode = context.getSourceCode();
-        const scope = context.getScope();
-        const objectVariable = scope.variables.filter(variable => variable.name === "Object");
-        const moduleReferences = scope.childScopes.filter(childScope => {
-            const varNamedObject = childScope.variables.filter(variable => variable.name === "Object");
-
-            return childScope.type === "module" && varNamedObject.length;
-        });
-        const references = [].concat(...objectVariable.map(variable => variable.references || []));
 
         return {
-            CallExpression(node) {
-
-                /*
-                 * If current file is either importing Object or redefining it,
-                 * we skip warning on this rule.
-                 */
-                if (moduleReferences.length || (references.length && modifyingObjectReference(references))) {
-                    return;
-                }
-
-                /*
-                 * The condition below is cases where Object.assign has a single argument and
-                 * that argument is an object literal. e.g. `Object.assign({ foo: bar })`.
-                 * For now, we will warn on this case and autofix it.
-                 */
-                if (
-                    node.arguments.length === 1 &&
-                    node.arguments[0].type === "ObjectExpression" &&
-                    isObjectAssign(node)
-                ) {
-                    context.report({
-                        node,
-                        messageId: "useLiteralMessage",
-                        fix: autofixObjectLiteral(node, sourceCode)
-                    });
-                }
-
-                /*
-                 * The condition below warns on `Object.assign` calls that that have
-                 * an object literal as the first argument and have a second argument
-                 * that can be spread. e.g `Object.assign({ foo: bar }, baz)`
-                 */
-                if (
-                    node.arguments.length > 1 &&
-                    node.arguments[0].type === "ObjectExpression" &&
-                    isObjectAssign(node) &&
-                    !hasArraySpread(node)
-                ) {
-                    context.report({
-                        node,
-                        messageId: "useSpreadMessage",
-                        fix: autofixSpread(node, sourceCode)
-                    });
+            Program() {
+                const scope = context.getScope();
+                const tracker = new ReferenceTracker(scope);
+                const trackMap = {
+                    Object: {
+                        assign: { [CALL]: true }
+                    }
+                };
+
+                // Iterate all calls of `Object.assign` (only of the global variable `Object`).
+                for (const { node } of tracker.iterateGlobalReferences(trackMap)) {
+                    if (
+                        node.arguments.length >= 1 &&
+                        node.arguments[0].type === "ObjectExpression" &&
+                        !hasArraySpread(node)
+                    ) {
+                        const messageId = node.arguments.length === 1
+                            ? "useLiteralMessage"
+                            : "useSpreadMessage";
+                        const fix = defineFixer(node, sourceCode);
+
+                        context.report({ node, messageId, fix });
+                    }
                 }
             }
         };

package/lib/rules/sort-keys.js

@@ -125,7 +125,7 @@ module.exports = {
             },
 
             Property(node) {
-                if (node.parent.type === "ObjectPattern") {
+                if (node.parent.type === "ObjectPattern" || node.parent.properties.some(n => n.type === "SpreadElement")) {
                     return;
                 }
 

package/lib/rules/wrap-regex.js

@@ -20,7 +20,10 @@ module.exports = {
 
         schema: [],
 
-        fixable: "code"
+        fixable: "code",
+        messages: {
+            requireParens: "Wrap the regexp literal in parens to disambiguate the slash."
+        }
     },
 
     create(context) {
@@ -33,15 +36,16 @@ module.exports = {
                     nodeType = token.type;
 
                 if (nodeType === "RegularExpression") {
-                    const source = sourceCode.getTokenBefore(node);
+                    const beforeToken = sourceCode.getTokenBefore(node);
+                    const afterToken = sourceCode.getTokenAfter(node);
                     const ancestors = context.getAncestors();
                     const grandparent = ancestors[ancestors.length - 1];
 
                     if (grandparent.type === "MemberExpression" && grandparent.object === node &&
-                        (!source || source.value !== "(")) {
+                        !(beforeToken && beforeToken.value === "(" && afterToken && afterToken.value === ")")) {
                         context.report({
                             node,
-                            message: "Wrap the regexp literal in parens to disambiguate the slash.",
+                            messageId: "requireParens",
                             fix: fixer => fixer.replaceText(node, `(${sourceCode.getText(node)})`)
                         });
                     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint",
-  "version": "5.0.1",
+  "version": "5.1.0",
   "author": "Nicholas C. Zakas <nicholas+npm@nczconsulting.com>",
   "description": "An AST-based pattern checker for JavaScript.",
   "bin": {
@@ -42,6 +42,7 @@
     "debug": "^3.1.0",
     "doctrine": "^2.1.0",
     "eslint-scope": "^4.0.0",
+    "eslint-utils": "^1.3.1",
     "eslint-visitor-keys": "^1.0.0",
     "espree": "^4.0.0",
     "esquery": "^1.0.1",
@@ -49,7 +50,7 @@
     "file-entry-cache": "^2.0.0",
     "functional-red-black-tree": "^1.0.1",
     "glob": "^7.1.2",
-    "globals": "^11.5.0",
+    "globals": "^11.7.0",
     "ignore": "^3.3.3",
     "imurmurhash": "^0.1.4",
     "inquirer": "^5.2.0",