eslint 7.10.0 → 7.13.0

package/lib/rules/space-before-blocks.js

@@ -5,8 +5,31 @@
 
 "use strict";
 
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
 const astUtils = require("./utils/ast-utils");
 
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+/**
+ * Checks whether the given node represents the body of a function.
+ * @param {ASTNode} node the node to check.
+ * @returns {boolean} `true` if the node is function body.
+ */
+function isFunctionBody(node) {
+    const parent = node.parent;
+
+    return (
+        node.type === "BlockStatement" &&
+        astUtils.isFunction(parent) &&
+        parent.body === node
+    );
+}
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -82,13 +105,16 @@ module.exports = {
         }
 
         /**
-         * Checks whether or not a given token is an arrow operator (=>) or a keyword
-         * in order to avoid to conflict with `arrow-spacing` and `keyword-spacing`.
-         * @param {Token} token A token to check.
-         * @returns {boolean} `true` if the token is an arrow operator.
+         * Checks whether the spacing before the given block is already controlled by another rule:
+         * - `arrow-spacing` checks spaces after `=>`.
+         * - `keyword-spacing` checks spaces after keywords in certain contexts.
+         * @param {Token} precedingToken first token before the block.
+         * @param {ASTNode|Token} node `BlockStatement` node or `{` token of a `SwitchStatement` node.
+         * @returns {boolean} `true` if requiring or disallowing spaces before the given block could produce conflicts with other rules.
          */
-        function isConflicted(token) {
-            return (token.type === "Punctuator" && token.value === "=>") || token.type === "Keyword";
+        function isConflicted(precedingToken, node) {
+            return astUtils.isArrowToken(precedingToken) ||
+                astUtils.isKeywordToken(precedingToken) && !isFunctionBody(node);
         }
 
         /**
@@ -99,13 +125,12 @@ module.exports = {
         function checkPrecedingSpace(node) {
             const precedingToken = sourceCode.getTokenBefore(node);
 
-            if (precedingToken && !isConflicted(precedingToken) && astUtils.isTokenOnSameLine(precedingToken, node)) {
+            if (precedingToken && !isConflicted(precedingToken, node) && astUtils.isTokenOnSameLine(precedingToken, node)) {
                 const hasSpace = sourceCode.isSpaceBetweenTokens(precedingToken, node);
-                const parent = context.getAncestors().pop();
                 let requireSpace;
                 let requireNoSpace;
 
-                if (parent.type === "FunctionExpression" || parent.type === "FunctionDeclaration") {
+                if (isFunctionBody(node)) {
                     requireSpace = alwaysFunctions;
                     requireNoSpace = neverFunctions;
                 } else if (node.type === "ClassBody") {

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

@@ -38,7 +38,9 @@ const LINEBREAKS = new Set(["\r\n", "\r", "\n", "\u2028", "\u2029"]);
 const STATEMENT_LIST_PARENTS = new Set(["Program", "BlockStatement", "SwitchCase"]);
 
 const DECIMAL_INTEGER_PATTERN = /^(?:0|0[0-7]*[89]\d*|[1-9](?:_?\d)*)$/u;
-const OCTAL_ESCAPE_PATTERN = /^(?:[^\\]|\\[^0-7]|\\0(?![0-9]))*\\(?:[1-7]|0[0-9])/u;
+
+// Tests the presence of at least one LegacyOctalEscapeSequence or NonOctalDecimalEscapeSequence in a raw string
+const OCTAL_OR_NON_OCTAL_DECIMAL_ESCAPE_PATTERN = /^(?:[^\\]|\\.)*\\(?:[1-9]|0[0-9])/su;
 
 const LOGICAL_ASSIGNMENT_OPERATORS = new Set(["&&=", "||=", "??="]);
 
@@ -1611,6 +1613,17 @@ module.exports = {
             }
 
             case "LogicalExpression":
+
+                /*
+                 * If the && operator short-circuits, the left side was falsy and therefore not an error, and if it
+                 * doesn't short-circuit, it takes the value from the right side, so the right side must always be
+                 * a plausible error. A future improvement could verify that the left side could be truthy by
+                 * excluding falsy literals.
+                 */
+                if (node.operator === "&&") {
+                    return module.exports.couldBeError(node.right);
+                }
+
                 return module.exports.couldBeError(node.left) || module.exports.couldBeError(node.right);
 
             case "ConditionalExpression":
@@ -1766,17 +1779,19 @@ module.exports = {
     },
 
     /**
-     * Determines whether the given raw string contains an octal escape sequence.
+     * Determines whether the given raw string contains an octal escape sequence
+     * or a non-octal decimal escape sequence ("\8", "\9").
      *
-     * "\1", "\2" ... "\7"
-     * "\00", "\01" ... "\09"
+     * "\1", "\2" ... "\7", "\8", "\9"
+     * "\00", "\01" ... "\07", "\08", "\09"
      *
      * "\0", when not followed by a digit, is not an octal escape sequence.
      * @param {string} rawString A string in its raw representation.
-     * @returns {boolean} `true` if the string contains at least one octal escape sequence.
+     * @returns {boolean} `true` if the string contains at least one octal escape sequence
+     * or at least one non-octal decimal escape sequence.
      */
-    hasOctalEscapeSequence(rawString) {
-        return OCTAL_ESCAPE_PATTERN.test(rawString);
+    hasOctalOrNonOctalDecimalEscapeSequence(rawString) {
+        return OCTAL_OR_NON_OCTAL_DECIMAL_ESCAPE_PATTERN.test(rawString);
     },
 
     isLogicalExpression,

package/lib/rules/yoda.js

@@ -265,36 +265,37 @@ module.exports = {
          * @returns {string} A string representation of the node with the sides and operator flipped
          */
         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 lastLeftToken = sourceCode.getTokenBefore(operatorToken);
             const firstRightToken = sourceCode.getTokenAfter(operatorToken);
-            const rightText = sourceCode
-                .getText()
-                .slice(firstRightToken.range[0], node.range[1]);
 
+            const source = sourceCode.getText();
+
+            const leftText = source.slice(
+                node.range[0],
+                lastLeftToken.range[1]
+            );
+            const textBeforeOperator = source.slice(
+                lastLeftToken.range[1],
+                operatorToken.range[0]
+            );
+            const textAfterOperator = source.slice(
+                operatorToken.range[1],
+                firstRightToken.range[0]
+            );
+            const rightText = source.slice(
+                firstRightToken.range[0],
+                node.range[1]
+            );
+
+            const tokenBefore = sourceCode.getTokenBefore(node);
+            const tokenAfter = sourceCode.getTokenAfter(node);
             let prefix = "";
+            let suffix = "";
 
             if (
                 tokenBefore &&
@@ -304,13 +305,22 @@ module.exports = {
                 prefix = " ";
             }
 
+            if (
+                tokenAfter &&
+                node.range[1] === tokenAfter.range[0] &&
+                !astUtils.canTokensBeAdjacent(lastLeftToken, tokenAfter)
+            ) {
+                suffix = " ";
+            }
+
             return (
                 prefix +
                 rightText +
                 textBeforeOperator +
                 OPERATOR_FLIP_MAP[operatorToken.value] +
                 textAfterOperator +
-                leftText
+                leftText +
+                suffix
             );
         }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "eslint",
-  "version": "7.10.0",
+  "version": "7.13.0",
   "author": "Nicholas C. Zakas <nicholas+npm@nczconsulting.com>",
   "description": "An AST-based pattern checker for JavaScript.",
   "bin": {
@@ -47,7 +47,7 @@
   "bugs": "https://github.com/eslint/eslint/issues/",
   "dependencies": {
     "@babel/code-frame": "^7.0.0",
-    "@eslint/eslintrc": "^0.1.3",
+    "@eslint/eslintrc": "^0.2.1",
     "ajv": "^6.10.0",
     "chalk": "^4.0.0",
     "cross-spawn": "^7.0.2",
@@ -56,7 +56,7 @@
     "enquirer": "^2.3.5",
     "eslint-scope": "^5.1.1",
     "eslint-utils": "^2.1.0",
-    "eslint-visitor-keys": "^1.3.0",
+    "eslint-visitor-keys": "^2.0.0",
     "espree": "^7.3.0",
     "esquery": "^1.2.0",
     "esutils": "^2.0.2",
@@ -105,6 +105,7 @@
     "eslint-release": "^2.0.0",
     "eslump": "^2.0.0",
     "esprima": "^4.0.1",
+    "fs-teardown": "^0.1.0",
     "glob": "^7.1.6",
     "jsdoc": "^3.5.5",
     "karma": "^4.0.1",