eslint 7.11.0 → 7.14.0

package/lib/rules/no-script-url.js

@@ -7,6 +7,8 @@
 
 "use strict";
 
+const astUtils = require("./utils/ast-utils");
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -31,18 +33,30 @@ module.exports = {
 
     create(context) {
 
+        /**
+         * Check whether a node's static value starts with "javascript:" or not.
+         * And report an error for unexpected script URL.
+         * @param {ASTNode} node node to check
+         * @returns {void}
+         */
+        function check(node) {
+            const value = astUtils.getStaticStringValue(node);
+
+            if (typeof value === "string" && value.toLowerCase().indexOf("javascript:") === 0) {
+                context.report({ node, messageId: "unexpectedScriptURL" });
+            }
+        }
         return {
-
             Literal(node) {
                 if (node.value && typeof node.value === "string") {
-                    const value = node.value.toLowerCase();
-
-                    if (value.indexOf("javascript:") === 0) {
-                        context.report({ node, messageId: "unexpectedScriptURL" });
-                    }
+                    check(node);
+                }
+            },
+            TemplateLiteral(node) {
+                if (!(node.parent && node.parent.type === "TaggedTemplateExpression")) {
+                    check(node);
                 }
             }
         };
-
     }
 };

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

@@ -162,6 +162,14 @@ module.exports = {
                 return;
             }
 
+            /*
+             * Prevent crashing on parsers which do not require class constructor
+             * to have a body, e.g. typescript and flow
+             */
+            if (!node.value.body) {
+                return;
+            }
+
             const body = node.value.body.body;
             const ctorParams = node.value.params;
             const superClass = node.parent.parent.superClass;

package/lib/rules/prefer-destructuring.js

@@ -4,6 +4,18 @@
  */
 "use strict";
 
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("./utils/ast-utils");
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+const PRECEDENCE_OF_ASSIGNMENT_EXPR = astUtils.getPrecedence({ type: "AssignmentExpression" });
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -185,9 +197,15 @@ module.exports = {
                 return null;
             }
 
+            let objectText = sourceCode.getText(rightNode.object);
+
+            if (astUtils.getPrecedence(rightNode.object) < PRECEDENCE_OF_ASSIGNMENT_EXPR) {
+                objectText = `(${objectText})`;
+            }
+
             return fixer.replaceText(
                 node,
-                `{${rightNode.property.name}} = ${sourceCode.getText(rightNode.object)}`
+                `{${rightNode.property.name}} = ${objectText}`
             );
         }
 

package/lib/rules/prefer-template.js

@@ -39,33 +39,25 @@ function getTopConcatBinaryExpression(node) {
 }
 
 /**
- * Determines whether a given node is a octal escape sequence
+ * Checks whether or not a node contains a string literal with an octal or non-octal decimal escape sequence
  * @param {ASTNode} node A node to check
- * @returns {boolean} `true` if the node is an octal escape sequence
+ * @returns {boolean} `true` if at least one string literal within the node contains
+ * an octal or non-octal decimal escape sequence
  */
-function isOctalEscapeSequence(node) {
-
-    // No need to check TemplateLiterals – would throw error with octal escape
-    const isStringLiteral = node.type === "Literal" && typeof node.value === "string";
-
-    if (!isStringLiteral) {
-        return false;
+function hasOctalOrNonOctalDecimalEscapeSequence(node) {
+    if (isConcatenation(node)) {
+        return (
+            hasOctalOrNonOctalDecimalEscapeSequence(node.left) ||
+            hasOctalOrNonOctalDecimalEscapeSequence(node.right)
+        );
     }
 
-    return astUtils.hasOctalEscapeSequence(node.raw);
-}
-
-/**
- * Checks whether or not a node contains a octal escape sequence
- * @param {ASTNode} node A node to check
- * @returns {boolean} `true` if the node contains an octal escape sequence
- */
-function hasOctalEscapeSequence(node) {
-    if (isConcatenation(node)) {
-        return hasOctalEscapeSequence(node.left) || hasOctalEscapeSequence(node.right);
+    // No need to check TemplateLiterals – would throw parsing error
+    if (node.type === "Literal" && typeof node.value === "string") {
+        return astUtils.hasOctalOrNonOctalDecimalEscapeSequence(node.raw);
     }
 
-    return isOctalEscapeSequence(node);
+    return false;
 }
 
 /**
@@ -237,7 +229,7 @@ module.exports = {
         function fixNonStringBinaryExpression(fixer, node) {
             const topBinaryExpr = getTopConcatBinaryExpression(node.parent);
 
-            if (hasOctalEscapeSequence(topBinaryExpr)) {
+            if (hasOctalOrNonOctalDecimalEscapeSequence(topBinaryExpr)) {
                 return null;
             }
 

package/lib/rules/quotes.js

@@ -282,9 +282,12 @@ module.exports = {
                                 description: settings.description
                             },
                             fix(fixer) {
-                                if (quoteOption === "backtick" && astUtils.hasOctalEscapeSequence(rawVal)) {
+                                if (quoteOption === "backtick" && astUtils.hasOctalOrNonOctalDecimalEscapeSequence(rawVal)) {
 
-                                    // An octal escape sequence in a template literal would produce syntax error, even in non-strict mode.
+                                    /*
+                                     * An octal or non-octal decimal escape sequence in a template literal would
+                                     * produce syntax error, even in non-strict mode.
+                                     */
                                     return null;
                                 }
 

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.11.0",
+  "version": "7.14.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",