eslint 7.0.0 → 7.3.1

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

@@ -147,10 +147,12 @@ module.exports = {
                         loc: node.consequent.loc.start,
                         messageId: "unnecessaryConditionalAssignment",
                         fix: fixer => {
-                            const shouldParenthesizeAlternate = (
-                                astUtils.getPrecedence(node.alternate) < OR_PRECEDENCE &&
-                                !astUtils.isParenthesised(sourceCode, node.alternate)
-                            );
+                            const shouldParenthesizeAlternate =
+                                (
+                                    astUtils.getPrecedence(node.alternate) < OR_PRECEDENCE ||
+                                    astUtils.isCoalesceExpression(node.alternate)
+                                ) &&
+                                !astUtils.isParenthesised(sourceCode, node.alternate);
                             const alternateText = shouldParenthesizeAlternate
                                 ? `(${sourceCode.getText(node.alternate)})`
                                 : astUtils.getParenthesisedText(sourceCode, node.alternate);

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/one-var-declaration-per-line.js

@@ -71,7 +71,7 @@ module.exports = {
                         context.report({
                             node,
                             messageId: "expectVarOnNewline",
-                            loc: current.loc.start,
+                            loc: current.loc,
                             fix: fixer => fixer.insertTextBefore(current, "\n")
                         });
                     }

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
             }
         ],
 
@@ -203,10 +204,14 @@ module.exports = {
             }
 
             if (requirePaddingFor(node)) {
+
                 if (!blockHasTopPadding) {
                     context.report({
                         node,
-                        loc: { line: tokenBeforeFirst.loc.start.line, column: tokenBeforeFirst.loc.start.column },
+                        loc: {
+                            start: tokenBeforeFirst.loc.start,
+                            end: firstBlockToken.loc.start
+                        },
                         fix(fixer) {
                             return fixer.insertTextAfter(tokenBeforeFirst, "\n");
                         },
@@ -216,7 +221,10 @@ module.exports = {
                 if (!blockHasBottomPadding) {
                     context.report({
                         node,
-                        loc: { line: tokenAfterLast.loc.end.line, column: tokenAfterLast.loc.end.column - 1 },
+                        loc: {
+                            end: tokenAfterLast.loc.start,
+                            start: lastBlockToken.loc.end
+                        },
                         fix(fixer) {
                             return fixer.insertTextBefore(tokenAfterLast, "\n");
                         },
@@ -228,7 +236,10 @@ module.exports = {
 
                     context.report({
                         node,
-                        loc: { line: tokenBeforeFirst.loc.start.line, column: tokenBeforeFirst.loc.start.column },
+                        loc: {
+                            start: tokenBeforeFirst.loc.start,
+                            end: firstBlockToken.loc.start
+                        },
                         fix(fixer) {
                             return fixer.replaceTextRange([tokenBeforeFirst.range[1], firstBlockToken.range[0] - firstBlockToken.loc.start.column], "\n");
                         },
@@ -240,7 +251,10 @@ module.exports = {
 
                     context.report({
                         node,
-                        loc: { line: tokenAfterLast.loc.end.line, column: tokenAfterLast.loc.end.column - 1 },
+                        loc: {
+                            end: tokenAfterLast.loc.start,
+                            start: lastBlockToken.loc.end
+                        },
                         messageId: "neverPadBlock",
                         fix(fixer) {
                             return fixer.replaceTextRange([lastBlockToken.range[1], tokenAfterLast.range[0] - tokenAfterLast.loc.start.column], "\n");

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/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/rest-spread-spacing.js

@@ -79,10 +79,7 @@ module.exports = {
             if (alwaysSpace && !hasWhitespace) {
                 context.report({
                     node,
-                    loc: {
-                        line: operator.loc.end.line,
-                        column: operator.loc.end.column
-                    },
+                    loc: operator.loc,
                     messageId: "expectedWhitespace",
                     data: {
                         type
@@ -95,8 +92,8 @@ module.exports = {
                 context.report({
                     node,
                     loc: {
-                        line: operator.loc.end.line,
-                        column: operator.loc.end.column
+                        start: operator.loc.end,
+                        end: nextToken.loc.start
                     },
                     messageId: "unexpectedWhitespace",
                     data: {

package/lib/rules/semi-spacing.js

@@ -117,6 +117,18 @@ module.exports = {
         }
 
         /**
+         * Report location example :
+         *
+         * for unexpected space `before`
+         *
+         * var a = 'b'   ;
+         *            ^^^
+         *
+         * for unexpected space `after`
+         *
+         * var a = 'b';  c = 10;
+         *             ^^
+         *
          * Reports if the given token has invalid spacing.
          * @param {Token} token The semicolon token to check.
          * @param {ASTNode} node The corresponding node of the token.
@@ -124,16 +136,19 @@ module.exports = {
          */
         function checkSemicolonSpacing(token, node) {
             if (astUtils.isSemicolonToken(token)) {
-                const location = token.loc.start;
-
                 if (hasLeadingSpace(token)) {
                     if (!requireSpaceBefore) {
+                        const tokenBefore = sourceCode.getTokenBefore(token);
+                        const loc = {
+                            start: tokenBefore.loc.end,
+                            end: token.loc.start
+                        };
+
                         context.report({
                             node,
-                            loc: location,
+                            loc,
                             messageId: "unexpectedWhitespaceBefore",
                             fix(fixer) {
-                                const tokenBefore = sourceCode.getTokenBefore(token);
 
                                 return fixer.removeRange([tokenBefore.range[1], token.range[0]]);
                             }
@@ -141,9 +156,11 @@ module.exports = {
                     }
                 } else {
                     if (requireSpaceBefore) {
+                        const loc = token.loc;
+
                         context.report({
                             node,
-                            loc: location,
+                            loc,
                             messageId: "missingWhitespaceBefore",
                             fix(fixer) {
                                 return fixer.insertTextBefore(token, " ");
@@ -155,12 +172,17 @@ module.exports = {
                 if (!isFirstTokenInCurrentLine(token) && !isLastTokenInCurrentLine(token) && !isBeforeClosingParen(token)) {
                     if (hasTrailingSpace(token)) {
                         if (!requireSpaceAfter) {
+                            const tokenAfter = sourceCode.getTokenAfter(token);
+                            const loc = {
+                                start: token.loc.end,
+                                end: tokenAfter.loc.start
+                            };
+
                             context.report({
                                 node,
-                                loc: location,
+                                loc,
                                 messageId: "unexpectedWhitespaceAfter",
                                 fix(fixer) {
-                                    const tokenAfter = sourceCode.getTokenAfter(token);
 
                                     return fixer.removeRange([token.range[1], tokenAfter.range[0]]);
                                 }
@@ -168,9 +190,11 @@ module.exports = {
                         }
                     } else {
                         if (requireSpaceAfter) {
+                            const loc = token.loc;
+
                             context.report({
                                 node,
-                                loc: location,
+                                loc,
                                 messageId: "missingWhitespaceAfter",
                                 fix(fixer) {
                                     return fixer.insertTextAfter(token, " ");
@@ -199,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;
@@ -1243,19 +1291,64 @@ module.exports = {
 
     /**
      * Gets next location when the result is not out of bound, otherwise returns null.
+     *
+     * Assumptions:
+     *
+     * - The given location represents a valid location in the given source code.
+     * - Columns are 0-based.
+     * - Lines are 1-based.
+     * - Column immediately after the last character in a line (not incl. linebreaks) is considered to be a valid location.
+     * - If the source code ends with a linebreak, `sourceCode.lines` array will have an extra element (empty string) at the end.
+     *   The start (column 0) of that extra line is considered to be a valid location.
+     *
+     * Examples of successive locations (line, column):
+     *
+     * code: foo
+     * locations: (1, 0) -> (1, 1) -> (1, 2) -> (1, 3) -> null
+     *
+     * code: foo<LF>
+     * locations: (1, 0) -> (1, 1) -> (1, 2) -> (1, 3) -> (2, 0) -> null
+     *
+     * code: foo<CR><LF>
+     * locations: (1, 0) -> (1, 1) -> (1, 2) -> (1, 3) -> (2, 0) -> null
+     *
+     * code: a<LF>b
+     * locations: (1, 0) -> (1, 1) -> (2, 0) -> (2, 1) -> null
+     *
+     * code: a<LF>b<LF>
+     * locations: (1, 0) -> (1, 1) -> (2, 0) -> (2, 1) -> (3, 0) -> null
+     *
+     * code: a<CR><LF>b<CR><LF>
+     * locations: (1, 0) -> (1, 1) -> (2, 0) -> (2, 1) -> (3, 0) -> null
+     *
+     * code: a<LF><LF>
+     * locations: (1, 0) -> (1, 1) -> (2, 0) -> (3, 0) -> null
+     *
+     * code: <LF>
+     * locations: (1, 0) -> (2, 0) -> null
+     *
+     * code:
+     * locations: (1, 0) -> null
      * @param {SourceCode} sourceCode The sourceCode
      * @param {{line: number, column: number}} location The location
      * @returns {{line: number, column: number} | null} Next location
      */
-    getNextLocation(sourceCode, location) {
-        const index = sourceCode.getIndexFromLoc(location);
+    getNextLocation(sourceCode, { line, column }) {
+        if (column < sourceCode.lines[line - 1].length) {
+            return {
+                line,
+                column: column + 1
+            };
+        }
 
-        // Avoid out of bound location
-        if (index + 1 > sourceCode.text.length) {
-            return null;
+        if (line < sourceCode.lines.length) {
+            return {
+                line: line + 1,
+                column: 0
+            };
         }
 
-        return sourceCode.getLocFromIndex(index + 1);
+        return null;
     },
 
     /**
@@ -1370,7 +1463,7 @@ module.exports = {
 
             try {
                 tokens = espree.tokenize(leftValue, espreeOptions);
-            } catch (e) {
+            } catch {
                 return false;
             }
 
@@ -1399,7 +1492,7 @@ module.exports = {
 
             try {
                 tokens = espree.tokenize(rightValue, espreeOptions);
-            } catch (e) {
+            } catch {
                 return false;
             }
 
@@ -1493,5 +1586,9 @@ module.exports = {
      */
     hasOctalEscapeSequence(rawString) {
         return OCTAL_ESCAPE_PATTERN.test(rawString);
-    }
+    },
+
+    isLogicalExpression,
+    isCoalesceExpression,
+    isMixedLogicalAndCoalesceExpressions
 };

package/lib/source-code/source-code.js

@@ -305,6 +305,7 @@ class SourceCode extends TokenStore {
      * @returns {Object} An object containing a leading and trailing array
      *      of comments indexed by their position.
      * @public
+     * @deprecated replaced by getCommentsBefore(), getCommentsAfter(), and getCommentsInside().
      */
     getComments(node) {
         if (this._commentCache.has(node)) {

package/messages/extend-config-missing.txt

@@ -2,4 +2,4 @@ ESLint couldn't find the config "<%- configName %>" to extend from. Please check
 
 The config "<%- configName %>" was referenced from the config file in "<%- importerName %>".
 
-If you still have problems, please stop by https://gitter.im/eslint/eslint to chat with the team.
+If you still have problems, please stop by https://eslint.org/chat to chat with the team.

package/messages/no-config-found.txt

@@ -4,4 +4,4 @@ ESLint couldn't find a configuration file. To set up a configuration file for th
 
 ESLint looked for configuration files in <%= directoryPath %> and its ancestors. If it found none, it then looked in your home directory.
 
-If you think you already have a configuration file or if you need more help, please stop by the ESLint chat room: https://gitter.im/eslint/eslint
+If you think you already have a configuration file or if you need more help, please stop by the ESLint chat room: https://eslint.org/chat

package/messages/plugin-conflict.txt

@@ -4,4 +4,4 @@ ESLint couldn't determine the plugin "<%- pluginId %>" uniquely.
 
 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.
+If you still can't figure out the problem, please stop by https://eslint.org/chat to chat with the team.