eslint 7.1.0 → 7.4.0

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

@@ -0,0 +1,150 @@
+/**
+ * @fileoverview Rule to disallow loops with a body that allows only one iteration
+ * @author Milos Djermanovic
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+const allLoopTypes = ["WhileStatement", "DoWhileStatement", "ForStatement", "ForInStatement", "ForOfStatement"];
+
+/**
+ * Determines whether the given node is the first node in the code path to which a loop statement
+ * 'loops' for the next iteration.
+ * @param {ASTNode} node The node to check.
+ * @returns {boolean} `true` if the node is a looping target.
+ */
+function isLoopingTarget(node) {
+    const parent = node.parent;
+
+    if (parent) {
+        switch (parent.type) {
+            case "WhileStatement":
+                return node === parent.test;
+            case "DoWhileStatement":
+                return node === parent.body;
+            case "ForStatement":
+                return node === (parent.update || parent.test || parent.body);
+            case "ForInStatement":
+            case "ForOfStatement":
+                return node === parent.left;
+
+            // no default
+        }
+    }
+
+    return false;
+}
+
+/**
+ * Creates an array with elements from the first given array that are not included in the second given array.
+ * @param {Array} arrA The array to compare from.
+ * @param {Array} arrB The array to compare against.
+ * @returns {Array} a new array that represents `arrA \ arrB`.
+ */
+function getDifference(arrA, arrB) {
+    return arrA.filter(a => !arrB.includes(a));
+}
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = {
+    meta: {
+        type: "problem",
+
+        docs: {
+            description: "disallow loops with a body that allows only one iteration",
+            category: "Possible Errors",
+            recommended: false,
+            url: "https://eslint.org/docs/rules/no-unreachable-loop"
+        },
+
+        schema: [{
+            type: "object",
+            properties: {
+                ignore: {
+                    type: "array",
+                    items: {
+                        enum: allLoopTypes
+                    },
+                    uniqueItems: true
+                }
+            },
+            additionalProperties: false
+        }],
+
+        messages: {
+            invalid: "Invalid loop. Its body allows only one iteration."
+        }
+    },
+
+    create(context) {
+        const ignoredLoopTypes = context.options[0] && context.options[0].ignore || [],
+            loopTypesToCheck = getDifference(allLoopTypes, ignoredLoopTypes),
+            loopSelector = loopTypesToCheck.join(","),
+            loopsByTargetSegments = new Map(),
+            loopsToReport = new Set();
+
+        let currentCodePath = null;
+
+        return {
+            onCodePathStart(codePath) {
+                currentCodePath = codePath;
+            },
+
+            onCodePathEnd() {
+                currentCodePath = currentCodePath.upper;
+            },
+
+            [loopSelector](node) {
+
+                /**
+                 * Ignore unreachable loop statements to avoid unnecessary complexity in the implementation, or false positives otherwise.
+                 * For unreachable segments, the code path analysis does not raise events required for this implementation.
+                 */
+                if (currentCodePath.currentSegments.some(segment => segment.reachable)) {
+                    loopsToReport.add(node);
+                }
+            },
+
+            onCodePathSegmentStart(segment, node) {
+                if (isLoopingTarget(node)) {
+                    const loop = node.parent;
+
+                    loopsByTargetSegments.set(segment, loop);
+                }
+            },
+
+            onCodePathSegmentLoop(_, toSegment, node) {
+                const loop = loopsByTargetSegments.get(toSegment);
+
+                /**
+                 * The second iteration is reachable, meaning that the loop is valid by the logic of this rule,
+                 * only if there is at least one loop event with the appropriate target (which has been already
+                 * determined in the `loopsByTargetSegments` map), raised from either:
+                 *
+                 * - the end of the loop's body (in which case `node === loop`)
+                 * - a `continue` statement
+                 *
+                 * This condition skips loop events raised from `ForInStatement > .right` and `ForOfStatement > .right` nodes.
+                 */
+                if (node === loop || node.type === "ContinueStatement") {
+
+                    // Removes loop if it exists in the set. Otherwise, `Set#delete` has no effect and doesn't throw.
+                    loopsToReport.delete(loop);
+                }
+            },
+
+            "Program:exit"() {
+                loopsToReport.forEach(
+                    node => context.report({ node, messageId: "invalid" })
+                );
+            }
+        };
+    }
+};

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

@@ -124,7 +124,7 @@ module.exports = {
                 return true;
             }
 
-            return /^(?:Assignment|Call|New|Update|Yield|Await)Expression$/u.test(node.type) ||
+            return /^(?:Assignment|Call|New|Update|Yield|Await|Import)Expression$/u.test(node.type) ||
                 (node.type === "UnaryExpression" && ["delete", "void"].indexOf(node.operator) >= 0);
         }
 

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

@@ -68,7 +68,8 @@ module.exports = {
                             caughtErrorsIgnorePattern: {
                                 type: "string"
                             }
-                        }
+                        },
+                        additionalProperties: false
                     }
                 ]
             }
@@ -619,7 +620,9 @@ module.exports = {
                     // Report the first declaration.
                     if (unusedVar.defs.length > 0) {
                         context.report({
-                            node: unusedVar.identifiers[0],
+                            node: unusedVar.references.length ? unusedVar.references[
+                                unusedVar.references.length - 1
+                            ].identifier : unusedVar.identifiers[0],
                             messageId: "unusedVar",
                             data: unusedVar.references.some(ref => ref.isWrite())
                                 ? getAssignedMessageData(unusedVar)

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

@@ -95,7 +95,7 @@ module.exports = {
 
             try {
                 regExpAST = parser.parsePattern(pattern, 0, pattern.length, flags.includes("u"));
-            } catch (e) {
+            } catch {
 
                 // Ignore regular expressions with syntax errors
                 return;

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

@@ -77,7 +77,7 @@ module.exports = {
                     if (lastTokenOfPreviousProperty.loc.end.line === firstTokenOfCurrentProperty.loc.start.line) {
                         context.report({
                             node,
-                            loc: firstTokenOfCurrentProperty.loc.start,
+                            loc: firstTokenOfCurrentProperty.loc,
                             messageId,
                             fix(fixer) {
                                 const comma = sourceCode.getTokenBefore(firstTokenOfCurrentProperty);

package/lib/rules/operator-linebreak.js

@@ -35,11 +35,8 @@ module.exports = {
                 properties: {
                     overrides: {
                         type: "object",
-                        properties: {
-                            anyOf: {
-                                type: "string",
-                                enum: ["after", "before", "none", "ignore"]
-                            }
+                        additionalProperties: {
+                            enum: ["after", "before", "none", "ignore"]
                         }
                     }
                 },

package/lib/rules/padded-blocks.js

@@ -58,7 +58,8 @@ module.exports = {
                     allowSingleLineBlocks: {
                         type: "boolean"
                     }
-                }
+                },
+                additionalProperties: false
             }
         ],
 

package/lib/rules/prefer-named-capture-group.js

@@ -59,7 +59,7 @@ module.exports = {
 
             try {
                 ast = parser.parsePattern(pattern, 0, pattern.length, uFlag);
-            } catch (_) {
+            } catch {
 
                 // ignore regex syntax errors
                 return;

package/lib/rules/prefer-regex-literals.js

@@ -25,6 +25,15 @@ function isStringLiteral(node) {
     return node.type === "Literal" && typeof node.value === "string";
 }
 
+/**
+ * Determines whether the given node is a regex literal.
+ * @param {ASTNode} node Node to check.
+ * @returns {boolean} True if the node is a regex literal.
+ */
+function isRegexLiteral(node) {
+    return node.type === "Literal" && Object.prototype.hasOwnProperty.call(node, "regex");
+}
+
 /**
  * Determines whether the given node is a template literal without expressions.
  * @param {ASTNode} node Node to check.
@@ -50,14 +59,28 @@ module.exports = {
             url: "https://eslint.org/docs/rules/prefer-regex-literals"
         },
 
-        schema: [],
+        schema: [
+            {
+                type: "object",
+                properties: {
+                    disallowRedundantWrapping: {
+                        type: "boolean",
+                        default: false
+                    }
+                },
+                additionalProperties: false
+            }
+        ],
 
         messages: {
-            unexpectedRegExp: "Use a regular expression literal instead of the 'RegExp' constructor."
+            unexpectedRegExp: "Use a regular expression literal instead of the 'RegExp' constructor.",
+            unexpectedRedundantRegExp: "Regular expression literal is unnecessarily wrapped within a 'RegExp' constructor.",
+            unexpectedRedundantRegExpWithFlags: "Use regular expression literal with flags instead of the 'RegExp' constructor."
         }
     },
 
     create(context) {
+        const [{ disallowRedundantWrapping = false } = {}] = context.options;
 
         /**
          * Determines whether the given identifier node is a reference to a global variable.
@@ -98,6 +121,40 @@ module.exports = {
                 isStringRawTaggedStaticTemplateLiteral(node);
         }
 
+        /**
+         * Determines whether the relevant arguments of the given are all static string literals.
+         * @param {ASTNode} node Node to check.
+         * @returns {boolean} True if all arguments are static strings.
+         */
+        function hasOnlyStaticStringArguments(node) {
+            const args = node.arguments;
+
+            if ((args.length === 1 || args.length === 2) && args.every(isStaticString)) {
+                return true;
+            }
+
+            return false;
+        }
+
+        /**
+         * Determines whether the arguments of the given node indicate that a regex literal is unnecessarily wrapped.
+         * @param {ASTNode} node Node to check.
+         * @returns {boolean} True if the node already contains a regex literal argument.
+         */
+        function isUnnecessarilyWrappedRegexLiteral(node) {
+            const args = node.arguments;
+
+            if (args.length === 1 && isRegexLiteral(args[0])) {
+                return true;
+            }
+
+            if (args.length === 2 && isRegexLiteral(args[0]) && isStaticString(args[1])) {
+                return true;
+            }
+
+            return false;
+        }
+
         return {
             Program() {
                 const scope = context.getScope();
@@ -110,12 +167,13 @@ module.exports = {
                 };
 
                 for (const { node } of tracker.iterateGlobalReferences(traceMap)) {
-                    const args = node.arguments;
-
-                    if (
-                        (args.length === 1 || args.length === 2) &&
-                        args.every(isStaticString)
-                    ) {
+                    if (disallowRedundantWrapping && isUnnecessarilyWrappedRegexLiteral(node)) {
+                        if (node.arguments.length === 2) {
+                            context.report({ node, messageId: "unexpectedRedundantRegExpWithFlags" });
+                        } else {
+                            context.report({ node, messageId: "unexpectedRedundantRegExp" });
+                        }
+                    } else if (hasOnlyStaticStringArguments(node)) {
                         context.report({ node, messageId: "unexpectedRegExp" });
                     }
                 }

package/lib/rules/quote-props.js

@@ -154,7 +154,7 @@ module.exports = {
 
                 try {
                     tokens = espree.tokenize(key.value);
-                } catch (e) {
+                } catch {
                     return;
                 }
 
@@ -239,7 +239,7 @@ module.exports = {
 
                         try {
                             tokens = espree.tokenize(key.value);
-                        } catch (e) {
+                        } catch {
                             necessaryQuotes = true;
                             return;
                         }

package/lib/rules/semi-spacing.js

@@ -223,6 +223,7 @@ module.exports = {
             BreakStatement: checkNode,
             ContinueStatement: checkNode,
             DebuggerStatement: checkNode,
+            DoWhileStatement: checkNode,
             ReturnStatement: checkNode,
             ThrowStatement: checkNode,
             ImportDeclaration: checkNode,

package/lib/rules/template-tag-spacing.js

@@ -49,7 +49,10 @@ module.exports = {
             if (never && hasWhitespace) {
                 context.report({
                     node,
-                    loc: tagToken.loc.start,
+                    loc: {
+                        start: tagToken.loc.end,
+                        end: literalToken.loc.start
+                    },
                     messageId: "unexpected",
                     fix(fixer) {
                         const comments = sourceCode.getCommentsBefore(node.quasi);
@@ -68,7 +71,10 @@ module.exports = {
             } else if (!never && !hasWhitespace) {
                 context.report({
                     node,
-                    loc: tagToken.loc.start,
+                    loc: {
+                        start: node.loc.start,
+                        end: literalToken.loc.start
+                    },
                     messageId: "missing",
                     fix(fixer) {
                         return fixer.insertTextAfter(tagToken, " ");

package/lib/rules/utils/ast-utils.js

@@ -416,6 +416,53 @@ function equalTokens(left, right, sourceCode) {
     return true;
 }
 
+/**
+ * Check if the given node is a true logical expression or not.
+ *
+ * The three binary expressions logical-or (`||`), logical-and (`&&`), and
+ * coalesce (`??`) are known as `ShortCircuitExpression`.
+ * But ESTree represents those by `LogicalExpression` node.
+ *
+ * This function rejects coalesce expressions of `LogicalExpression` node.
+ * @param {ASTNode} node The node to check.
+ * @returns {boolean} `true` if the node is `&&` or `||`.
+ * @see https://tc39.es/ecma262/#prod-ShortCircuitExpression
+ */
+function isLogicalExpression(node) {
+    return (
+        node.type === "LogicalExpression" &&
+            (node.operator === "&&" || node.operator === "||")
+    );
+}
+
+/**
+ * Check if the given node is a nullish coalescing expression or not.
+ *
+ * The three binary expressions logical-or (`||`), logical-and (`&&`), and
+ * coalesce (`??`) are known as `ShortCircuitExpression`.
+ * But ESTree represents those by `LogicalExpression` node.
+ *
+ * This function finds only coalesce expressions of `LogicalExpression` node.
+ * @param {ASTNode} node The node to check.
+ * @returns {boolean} `true` if the node is `??`.
+ */
+function isCoalesceExpression(node) {
+    return node.type === "LogicalExpression" && node.operator === "??";
+}
+
+/**
+ * Check if given two nodes are the pair of a logical expression and a coalesce expression.
+ * @param {ASTNode} left A node to check.
+ * @param {ASTNode} right Another node to check.
+ * @returns {boolean} `true` if the two nodes are the pair of a logical expression and a coalesce expression.
+ */
+function isMixedLogicalAndCoalesceExpressions(left, right) {
+    return (
+        (isLogicalExpression(left) && isCoalesceExpression(right)) ||
+            (isCoalesceExpression(left) && isLogicalExpression(right))
+    );
+}
+
 //------------------------------------------------------------------------------
 // Public Interface
 //------------------------------------------------------------------------------
@@ -779,6 +826,7 @@ module.exports = {
             case "LogicalExpression":
                 switch (node.operator) {
                     case "||":
+                    case "??":
                         return 4;
                     case "&&":
                         return 5;
@@ -1415,7 +1463,7 @@ module.exports = {
 
             try {
                 tokens = espree.tokenize(leftValue, espreeOptions);
-            } catch (e) {
+            } catch {
                 return false;
             }
 
@@ -1444,7 +1492,7 @@ module.exports = {
 
             try {
                 tokens = espree.tokenize(rightValue, espreeOptions);
-            } catch (e) {
+            } catch {
                 return false;
             }
 
@@ -1538,5 +1586,9 @@ module.exports = {
      */
     hasOctalEscapeSequence(rawString) {
         return OCTAL_ESCAPE_PATTERN.test(rawString);
-    }
+    },
+
+    isLogicalExpression,
+    isCoalesceExpression,
+    isMixedLogicalAndCoalesceExpressions
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint",
-  "version": "7.1.0",
+  "version": "7.4.0",
   "author": "Nicholas C. Zakas <nicholas+npm@nczconsulting.com>",
   "description": "An AST-based pattern checker for JavaScript.",
   "bin": {
@@ -52,10 +52,11 @@
     "cross-spawn": "^7.0.2",
     "debug": "^4.0.1",
     "doctrine": "^3.0.0",
-    "eslint-scope": "^5.0.0",
+    "enquirer": "^2.3.5",
+    "eslint-scope": "^5.1.0",
     "eslint-utils": "^2.0.0",
-    "eslint-visitor-keys": "^1.1.0",
-    "espree": "^7.0.0",
+    "eslint-visitor-keys": "^1.2.0",
+    "espree": "^7.1.0",
     "esquery": "^1.2.0",
     "esutils": "^2.0.2",
     "file-entry-cache": "^5.0.1",
@@ -65,7 +66,6 @@
     "ignore": "^4.0.6",
     "import-fresh": "^3.0.0",
     "imurmurhash": "^0.1.4",
-    "inquirer": "^7.0.0",
     "is-glob": "^4.0.0",
     "js-yaml": "^3.13.1",
     "json-stable-stringify-without-jsonify": "^1.0.1",
@@ -86,7 +86,7 @@
   "devDependencies": {
     "@babel/core": "^7.4.3",
     "@babel/preset-env": "^7.4.3",
-    "acorn": "^7.1.1",
+    "acorn": "^7.2.0",
     "babel-loader": "^8.0.5",
     "chai": "^4.0.1",
     "cheerio": "^0.22.0",