eslint 7.0.0-alpha.1 → 7.0.0

package/lib/rules/wrap-iife.js

@@ -10,6 +10,21 @@
 //------------------------------------------------------------------------------
 
 const astUtils = require("./utils/ast-utils");
+const eslintUtils = require("eslint-utils");
+
+//----------------------------------------------------------------------
+// Helpers
+//----------------------------------------------------------------------
+
+/**
+ * Check if the given node is callee of a `NewExpression` node
+ * @param {ASTNode} node node to check
+ * @returns {boolean} True if the node is callee of a `NewExpression` node
+ * @private
+ */
+function isCalleeOfNewExpression(node) {
+    return node.parent.type === "NewExpression" && node.parent.callee === node;
+}
 
 //------------------------------------------------------------------------------
 // Rule Definition
@@ -58,15 +73,25 @@ module.exports = {
         const sourceCode = context.getSourceCode();
 
         /**
-         * Check if the node is wrapped in ()
+         * Check if the node is wrapped in any (). All parens count: grouping parens and parens for constructs such as if()
          * @param {ASTNode} node node to evaluate
-         * @returns {boolean} True if it is wrapped
+         * @returns {boolean} True if it is wrapped in any parens
          * @private
          */
-        function wrapped(node) {
+        function isWrappedInAnyParens(node) {
             return astUtils.isParenthesised(sourceCode, node);
         }
 
+        /**
+         * Check if the node is wrapped in grouping (). Parens for constructs such as if() don't count
+         * @param {ASTNode} node node to evaluate
+         * @returns {boolean} True if it is wrapped in grouping parens
+         * @private
+         */
+        function isWrappedInGroupingParens(node) {
+            return eslintUtils.isParenthesized(1, node, sourceCode);
+        }
+
         /**
          * Get the function node from an IIFE
          * @param {ASTNode} node node to evaluate
@@ -99,10 +124,10 @@ module.exports = {
                     return;
                 }
 
-                const callExpressionWrapped = wrapped(node),
-                    functionExpressionWrapped = wrapped(innerNode);
+                const isCallExpressionWrapped = isWrappedInAnyParens(node),
+                    isFunctionExpressionWrapped = isWrappedInAnyParens(innerNode);
 
-                if (!callExpressionWrapped && !functionExpressionWrapped) {
+                if (!isCallExpressionWrapped && !isFunctionExpressionWrapped) {
                     context.report({
                         node,
                         messageId: "wrapInvocation",
@@ -112,27 +137,39 @@ module.exports = {
                             return fixer.replaceText(nodeToSurround, `(${sourceCode.getText(nodeToSurround)})`);
                         }
                     });
-                } else if (style === "inside" && !functionExpressionWrapped) {
+                } else if (style === "inside" && !isFunctionExpressionWrapped) {
                     context.report({
                         node,
                         messageId: "wrapExpression",
                         fix(fixer) {
 
+                            // The outer call expression will always be wrapped at this point.
+
+                            if (isWrappedInGroupingParens(node) && !isCalleeOfNewExpression(node)) {
+
+                                /*
+                                 * Parenthesize the function expression and remove unnecessary grouping parens around the call expression.
+                                 * Replace the range between the end of the function expression and the end of the call expression.
+                                 * for example, in `(function(foo) {}(bar))`, the range `(bar))` should get replaced with `)(bar)`.
+                                 */
+
+                                const parenAfter = sourceCode.getTokenAfter(node);
+
+                                return fixer.replaceTextRange(
+                                    [innerNode.range[1], parenAfter.range[1]],
+                                    `)${sourceCode.getText().slice(innerNode.range[1], parenAfter.range[0])}`
+                                );
+                            }
+
                             /*
-                             * The outer call expression will always be wrapped at this point.
-                             * Replace the range between the end of the function expression and the end of the call expression.
-                             * for example, in `(function(foo) {}(bar))`, the range `(bar))` should get replaced with `)(bar)`.
-                             * Replace the parens from the outer expression, and parenthesize the function expression.
+                             * Call expression is wrapped in mandatory parens such as if(), or in necessary grouping parens.
+                             * These parens cannot be removed, so just parenthesize the function expression.
                              */
-                            const parenAfter = sourceCode.getTokenAfter(node);
 
-                            return fixer.replaceTextRange(
-                                [innerNode.range[1], parenAfter.range[1]],
-                                `)${sourceCode.getText().slice(innerNode.range[1], parenAfter.range[0])}`
-                            );
+                            return fixer.replaceText(innerNode, `(${sourceCode.getText(innerNode)})`);
                         }
                     });
-                } else if (style === "outside" && !callExpressionWrapped) {
+                } else if (style === "outside" && !isCallExpressionWrapped) {
                     context.report({
                         node,
                         messageId: "moveInvocation",

package/lib/rules/yoda.js

@@ -20,7 +20,7 @@ const astUtils = require("./utils/ast-utils");
  * @returns {boolean} Whether or not it is a comparison operator.
  */
 function isComparisonOperator(operator) {
-    return (/^(==|===|!=|!==|<|>|<=|>=)$/u).test(operator);
+    return /^(==|===|!=|!==|<|>|<=|>=)$/u.test(operator);
 }
 
 /**
@@ -29,7 +29,7 @@ function isComparisonOperator(operator) {
  * @returns {boolean} Whether or not it is an equality operator.
  */
 function isEqualityOperator(operator) {
-    return (/^(==|===)$/u).test(operator);
+    return /^(==|===)$/u.test(operator);
 }
 
 /**
@@ -50,10 +50,12 @@ function isRangeTestOperator(operator) {
  *                    real literal and should be treated as such.
  */
 function isNegativeNumericLiteral(node) {
-    return (node.type === "UnaryExpression" &&
+    return (
+        node.type === "UnaryExpression" &&
         node.operator === "-" &&
         node.prefix &&
-        astUtils.isNumericLiteral(node.argument));
+        astUtils.isNumericLiteral(node.argument)
+    );
 }
 
 /**
@@ -71,25 +73,21 @@ function isStaticTemplateLiteral(node) {
  * @returns {boolean} True if the node should be treated as a single Literal node.
  */
 function looksLikeLiteral(node) {
-    return isNegativeNumericLiteral(node) ||
-        isStaticTemplateLiteral(node);
+    return isNegativeNumericLiteral(node) || isStaticTemplateLiteral(node);
 }
 
 /**
  * Attempts to derive a Literal node from nodes that are treated like literals.
  * @param {ASTNode} node Node to normalize.
- * @param {number} [defaultValue] The default value to be returned if the node
- *                                is not a Literal.
  * @returns {ASTNode} One of the following options.
  *  1. The original node if the node is already a Literal
  *  2. A normalized Literal node with the negative number as the value if the
  *     node represents a negative number literal.
  *  3. A normalized Literal node with the string as the value if the node is
  *     a Template Literal without expression.
- *  4. The Literal node which has the `defaultValue` argument if it exists.
- *  5. Otherwise `null`.
+ *  4. Otherwise `null`.
  */
-function getNormalizedLiteral(node, defaultValue) {
+function getNormalizedLiteral(node) {
     if (node.type === "Literal") {
         return node;
     }
@@ -110,14 +108,6 @@ function getNormalizedLiteral(node, defaultValue) {
         };
     }
 
-    if (defaultValue) {
-        return {
-            type: "Literal",
-            value: defaultValue,
-            raw: String(defaultValue)
-        };
-    }
-
     return null;
 }
 
@@ -183,7 +173,7 @@ module.exports = {
         type: "suggestion",
 
         docs: {
-            description: "require or disallow \"Yoda\" conditions",
+            description: 'require or disallow "Yoda" conditions',
             category: "Best Practices",
             recommended: false,
             url: "https://eslint.org/docs/rules/yoda"
@@ -211,16 +201,19 @@ module.exports = {
 
         fixable: "code",
         messages: {
-            expected: "Expected literal to be on the {{expectedSide}} side of {{operator}}."
+            expected:
+                "Expected literal to be on the {{expectedSide}} side of {{operator}}."
         }
     },
 
     create(context) {
 
         // Default to "never" (!always) if no option
-        const always = (context.options[0] === "always");
-        const exceptRange = (context.options[1] && context.options[1].exceptRange);
-        const onlyEquality = (context.options[1] && context.options[1].onlyEquality);
+        const always = context.options[0] === "always";
+        const exceptRange =
+            context.options[1] && context.options[1].exceptRange;
+        const onlyEquality =
+            context.options[1] && context.options[1].onlyEquality;
 
         const sourceCode = context.getSourceCode();
 
@@ -243,13 +236,23 @@ module.exports = {
              * @returns {boolean} Whether node is a "between" range test.
              */
             function isBetweenTest() {
-                let leftLiteral, rightLiteral;
+                if (node.operator === "&&" && same(left.right, right.left)) {
+                    const leftLiteral = getNormalizedLiteral(left.left);
+                    const rightLiteral = getNormalizedLiteral(right.right);
+
+                    if (leftLiteral === null && rightLiteral === null) {
+                        return false;
+                    }
 
-                return (node.operator === "&&" &&
-                    (leftLiteral = getNormalizedLiteral(left.left)) &&
-                    (rightLiteral = getNormalizedLiteral(right.right, Number.POSITIVE_INFINITY)) &&
-                    leftLiteral.value <= rightLiteral.value &&
-                    same(left.right, right.left));
+                    if (rightLiteral === null || leftLiteral === null) {
+                        return true;
+                    }
+
+                    if (leftLiteral.value <= rightLiteral.value) {
+                        return true;
+                    }
+                }
+                return false;
             }
 
             /**
@@ -257,13 +260,24 @@ module.exports = {
              * @returns {boolean} Whether node is an "outside" range test.
              */
             function isOutsideTest() {
-                let leftLiteral, rightLiteral;
+                if (node.operator === "||" && same(left.left, right.right)) {
+                    const leftLiteral = getNormalizedLiteral(left.right);
+                    const rightLiteral = getNormalizedLiteral(right.left);
+
+                    if (leftLiteral === null && rightLiteral === null) {
+                        return false;
+                    }
+
+                    if (rightLiteral === null || leftLiteral === null) {
+                        return true;
+                    }
+
+                    if (leftLiteral.value <= rightLiteral.value) {
+                        return true;
+                    }
+                }
 
-                return (node.operator === "||" &&
-                    (leftLiteral = getNormalizedLiteral(left.right, Number.NEGATIVE_INFINITY)) &&
-                    (rightLiteral = getNormalizedLiteral(right.left)) &&
-                    leftLiteral.value <= rightLiteral.value &&
-                    same(left.left, right.right));
+                return false;
             }
 
             /**
@@ -276,13 +290,15 @@ module.exports = {
                 return astUtils.isParenthesised(sourceCode, node);
             }
 
-            return (node.type === "LogicalExpression" &&
+            return (
+                node.type === "LogicalExpression" &&
                 left.type === "BinaryExpression" &&
                 right.type === "BinaryExpression" &&
                 isRangeTestOperator(left.operator) &&
                 isRangeTestOperator(right.operator) &&
                 (isBetweenTest() || isOutsideTest()) &&
-                isParenWrapped());
+                isParenWrapped()
+            );
         }
 
         const OPERATOR_FLIP_MAP = {
@@ -303,21 +319,52 @@ module.exports = {
          */
         function getFlippedString(node) {
             const tokenBefore = sourceCode.getTokenBefore(node);
-            const operatorToken = sourceCode.getFirstTokenBetween(node.left, node.right, token => token.value === node.operator);
-            const textBeforeOperator = sourceCode.getText().slice(sourceCode.getTokenBefore(operatorToken).range[1], operatorToken.range[0]);
-            const textAfterOperator = sourceCode.getText().slice(operatorToken.range[1], sourceCode.getTokenAfter(operatorToken).range[0]);
-            const leftText = sourceCode.getText().slice(node.range[0], sourceCode.getTokenBefore(operatorToken).range[1]);
+            const operatorToken = sourceCode.getFirstTokenBetween(
+                node.left,
+                node.right,
+                token => token.value === node.operator
+            );
+            const textBeforeOperator = sourceCode
+                .getText()
+                .slice(
+                    sourceCode.getTokenBefore(operatorToken).range[1],
+                    operatorToken.range[0]
+                );
+            const textAfterOperator = sourceCode
+                .getText()
+                .slice(
+                    operatorToken.range[1],
+                    sourceCode.getTokenAfter(operatorToken).range[0]
+                );
+            const leftText = sourceCode
+                .getText()
+                .slice(
+                    node.range[0],
+                    sourceCode.getTokenBefore(operatorToken).range[1]
+                );
             const firstRightToken = sourceCode.getTokenAfter(operatorToken);
-            const rightText = sourceCode.getText().slice(firstRightToken.range[0], node.range[1]);
+            const rightText = sourceCode
+                .getText()
+                .slice(firstRightToken.range[0], node.range[1]);
 
             let prefix = "";
 
-            if (tokenBefore && tokenBefore.range[1] === node.range[0] &&
-                    !astUtils.canTokensBeAdjacent(tokenBefore, firstRightToken)) {
+            if (
+                tokenBefore &&
+                tokenBefore.range[1] === node.range[0] &&
+                !astUtils.canTokensBeAdjacent(tokenBefore, firstRightToken)
+            ) {
                 prefix = " ";
             }
 
-            return prefix + rightText + textBeforeOperator + OPERATOR_FLIP_MAP[operatorToken.value] + textAfterOperator + leftText;
+            return (
+                prefix +
+                rightText +
+                textBeforeOperator +
+                OPERATOR_FLIP_MAP[operatorToken.value] +
+                textAfterOperator +
+                leftText
+            );
         }
 
         //--------------------------------------------------------------------------
@@ -331,8 +378,12 @@ module.exports = {
 
                 // If `expectedLiteral` is not a literal, and `expectedNonLiteral` is a literal, raise an error.
                 if (
-                    (expectedNonLiteral.type === "Literal" || looksLikeLiteral(expectedNonLiteral)) &&
-                    !(expectedLiteral.type === "Literal" || looksLikeLiteral(expectedLiteral)) &&
+                    (expectedNonLiteral.type === "Literal" ||
+                        looksLikeLiteral(expectedNonLiteral)) &&
+                    !(
+                        expectedLiteral.type === "Literal" ||
+                        looksLikeLiteral(expectedLiteral)
+                    ) &&
                     !(!isEqualityOperator(node.operator) && onlyEquality) &&
                     isComparisonOperator(node.operator) &&
                     !(exceptRange && isRangeTest(context.getAncestors().pop()))
@@ -344,12 +395,11 @@ module.exports = {
                             operator: node.operator,
                             expectedSide: always ? "left" : "right"
                         },
-                        fix: fixer => fixer.replaceText(node, getFlippedString(node))
+                        fix: fixer =>
+                            fixer.replaceText(node, getFlippedString(node))
                     });
                 }
-
             }
         };
-
     }
 };

package/lib/shared/relative-module-resolver.js

@@ -11,6 +11,7 @@ const Module = require("module");
  * `Module.createRequire` is added in v12.2.0. It supports URL as well.
  * We only support the case where the argument is a filepath, not a URL.
  */
+// eslint-disable-next-line node/no-unsupported-features/node-builtins, node/no-deprecated-api
 const createRequire = Module.createRequire || Module.createRequireFromPath;
 
 module.exports = {

package/lib/shared/types.js

@@ -37,7 +37,7 @@ module.exports = {};
  * @property {ParserOptions} [parserOptions] The parser options.
  * @property {string[]} [plugins] The plugin specifiers.
  * @property {string} [processor] The processor specifier.
- * @property {boolean|undefined} reportUnusedDisableDirectives The flag to report unused `eslint-disable` comments.
+ * @property {boolean} [reportUnusedDisableDirectives] The flag to report unused `eslint-disable` comments.
  * @property {boolean} [root] The root flag.
  * @property {Record<string, RuleConf>} [rules] The rule settings.
  * @property {Object} [settings] The shared settings.
@@ -56,7 +56,7 @@ module.exports = {};
  * @property {ParserOptions} [parserOptions] The parser options.
  * @property {string[]} [plugins] The plugin specifiers.
  * @property {string} [processor] The processor specifier.
- * @property {boolean|undefined} reportUnusedDisableDirectives The flag to report unused `eslint-disable` comments.
+ * @property {boolean} [reportUnusedDisableDirectives] The flag to report unused `eslint-disable` comments.
  * @property {Record<string, RuleConf>} [rules] The rule settings.
  * @property {Object} [settings] The shared settings.
  */
@@ -141,3 +141,10 @@ module.exports = {};
  * @property {Record<string, Processor>} [processors] The definition of plugin processors.
  * @property {Record<string, Function | Rule>} [rules] The definition of plugin rules.
  */
+
+/**
+ * Information of deprecated rules.
+ * @typedef {Object} DeprecatedRuleInfo
+ * @property {string} ruleId The rule ID.
+ * @property {string[]} replacedBy The rule IDs that replace this deprecated rule.
+ */

package/messages/plugin-conflict.txt

@@ -0,0 +1,7 @@
+ESLint couldn't determine the plugin "<%- pluginId %>" uniquely.
+<% for (const { filePath, importerName } of plugins) { %>
+- <%= filePath %> (loaded in "<%= importerName %>")<% } %>
+
+Please remove the "plugins" setting from either config or remove either plugin installation.
+
+If you still can't figure out the problem, please stop by https://gitter.im/eslint/eslint to chat with the team.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint",
-  "version": "7.0.0-alpha.1",
+  "version": "7.0.0",
   "author": "Nicholas C. Zakas <nicholas+npm@nczconsulting.com>",
   "description": "An AST-based pattern checker for JavaScript.",
   "bin": {
@@ -48,15 +48,15 @@
   "dependencies": {
     "@babel/code-frame": "^7.0.0",
     "ajv": "^6.10.0",
-    "chalk": "^3.0.0",
-    "cross-spawn": "^7.0.1",
+    "chalk": "^4.0.0",
+    "cross-spawn": "^7.0.2",
     "debug": "^4.0.1",
     "doctrine": "^3.0.0",
     "eslint-scope": "^5.0.0",
-    "eslint-utils": "^1.4.3",
+    "eslint-utils": "^2.0.0",
     "eslint-visitor-keys": "^1.1.0",
-    "espree": "^6.1.2",
-    "esquery": "^1.0.1",
+    "espree": "^7.0.0",
+    "esquery": "^1.2.0",
     "esutils": "^2.0.2",
     "file-entry-cache": "^5.0.1",
     "functional-red-black-tree": "^1.0.1",
@@ -69,16 +69,16 @@
     "is-glob": "^4.0.0",
     "js-yaml": "^3.13.1",
     "json-stable-stringify-without-jsonify": "^1.0.1",
-    "levn": "^0.3.0",
+    "levn": "^0.4.1",
     "lodash": "^4.17.14",
     "minimatch": "^3.0.4",
     "natural-compare": "^1.4.0",
-    "optionator": "^0.8.3",
+    "optionator": "^0.9.1",
     "progress": "^2.0.0",
-    "regexpp": "^3.0.0",
-    "semver": "^7.1.1",
+    "regexpp": "^3.1.0",
+    "semver": "^7.2.1",
     "strip-ansi": "^6.0.0",
-    "strip-json-comments": "^3.0.1",
+    "strip-json-comments": "^3.1.0",
     "table": "^5.2.3",
     "text-table": "^0.2.0",
     "v8-compile-cache": "^2.0.3"
@@ -86,46 +86,47 @@
   "devDependencies": {
     "@babel/core": "^7.4.3",
     "@babel/preset-env": "^7.4.3",
-    "acorn": "^7.1.0",
+    "acorn": "^7.1.1",
     "babel-loader": "^8.0.5",
     "chai": "^4.0.1",
     "cheerio": "^0.22.0",
     "common-tags": "^1.8.0",
     "core-js": "^3.1.3",
     "dateformat": "^3.0.3",
-    "ejs": "^2.6.1",
+    "ejs": "^3.0.2",
+    "escape-string-regexp": "^3.0.0",
     "eslint": "file:.",
     "eslint-config-eslint": "file:packages/eslint-config-eslint",
     "eslint-plugin-eslint-plugin": "^2.2.1",
     "eslint-plugin-internal-rules": "file:tools/internal-rules",
-    "eslint-plugin-jsdoc": "^15.9.5",
-    "eslint-plugin-node": "^9.0.0",
-    "eslint-release": "^1.2.0",
+    "eslint-plugin-jsdoc": "^22.1.0",
+    "eslint-plugin-node": "^11.1.0",
+    "eslint-release": "^2.0.0",
     "eslump": "^2.0.0",
     "esprima": "^4.0.1",
-    "glob": "^7.1.3",
+    "glob": "^7.1.6",
     "jsdoc": "^3.5.5",
     "karma": "^4.0.1",
-    "karma-chrome-launcher": "^2.2.0",
+    "karma-chrome-launcher": "^3.1.0",
     "karma-mocha": "^1.3.0",
     "karma-mocha-reporter": "^2.2.3",
     "karma-webpack": "^4.0.0-rc.6",
     "leche": "^2.2.3",
-    "lint-staged": "^8.1.5",
+    "lint-staged": "^10.1.2",
     "load-perf": "^0.2.0",
-    "markdownlint": "^0.15.0",
-    "markdownlint-cli": "^0.17.0",
+    "markdownlint": "^0.19.0",
+    "markdownlint-cli": "^0.22.0",
     "memfs": "^3.0.1",
-    "mocha": "^6.1.2",
+    "mocha": "^7.1.1",
     "mocha-junit-reporter": "^1.23.0",
     "npm-license": "^0.3.3",
-    "nyc": "^14.1.1",
+    "nyc": "^15.0.1",
     "proxyquire": "^2.0.1",
-    "puppeteer": "^1.18.0",
-    "recast": "^0.18.1",
+    "puppeteer": "^2.1.1",
+    "recast": "^0.19.0",
     "regenerator-runtime": "^0.13.2",
     "shelljs": "^0.8.2",
-    "sinon": "^7.3.2",
+    "sinon": "^9.0.1",
     "temp": "^0.9.0",
     "webpack": "^4.35.0",
     "webpack-cli": "^3.3.5",