eslint 6.3.0 → 6.4.0

package/lib/rules/no-lone-blocks.js

@@ -79,7 +79,7 @@ module.exports = {
             }
         };
 
-        // ES6: report blocks without block-level bindings
+        // ES6: report blocks without block-level bindings, or that's only child of another block
         if (context.parserOptions.ecmaVersion >= 6) {
             ruleDef = {
                 BlockStatement(node) {
@@ -91,6 +91,11 @@ module.exports = {
                     if (loneBlocks.length > 0 && loneBlocks[loneBlocks.length - 1] === node) {
                         loneBlocks.pop();
                         report(node);
+                    } else if (
+                        node.parent.type === "BlockStatement" &&
+                        node.parent.body.length === 1
+                    ) {
+                        report(node);
                     }
                 }
             };

package/lib/rules/no-obj-calls.js

@@ -5,6 +5,18 @@
 
 "use strict";
 
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const { CALL, ReferenceTracker } = require("eslint-utils");
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+const nonCallableGlobals = ["Atomics", "JSON", "Math", "Reflect"];
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -20,23 +32,31 @@ module.exports = {
             url: "https://eslint.org/docs/rules/no-obj-calls"
         },
 
-        schema: []
+        schema: [],
+
+        messages: {
+            unexpectedCall: "'{{name}}' is not a function."
+        }
     },
 
     create(context) {
 
         return {
-            CallExpression(node) {
-
-                if (node.callee.type === "Identifier") {
-                    const name = node.callee.name;
+            Program() {
+                const scope = context.getScope();
+                const tracker = new ReferenceTracker(scope);
+                const traceMap = {};
+
+                for (const global of nonCallableGlobals) {
+                    traceMap[global] = {
+                        [CALL]: true
+                    };
+                }
 
-                    if (name === "Math" || name === "JSON" || name === "Reflect") {
-                        context.report({ node, message: "'{{name}}' is not a function.", data: { name } });
-                    }
+                for (const { node } of tracker.iterateGlobalReferences(traceMap)) {
+                    context.report({ node, messageId: "unexpectedCall", data: { name: node.callee.name } });
                 }
             }
         };
-
     }
 };

package/lib/rules/no-octal-escape.js

@@ -20,7 +20,11 @@ module.exports = {
             url: "https://eslint.org/docs/rules/no-octal-escape"
         },
 
-        schema: []
+        schema: [],
+
+        messages: {
+            octalEscapeSequence: "Don't use octal: '\\{{sequence}}'. Use '\\u....' instead."
+        }
     },
 
     create(context) {
@@ -32,15 +36,17 @@ module.exports = {
                     return;
                 }
 
-                const match = node.raw.match(/^([^\\]|\\[^0-7])*\\([0-3][0-7]{1,2}|[4-7][0-7]|[0-7])/u);
+                // \0 represents a valid NULL character if it isn't followed by a digit.
+                const match = node.raw.match(
+                    /^(?:[^\\]|\\.)*?\\([0-3][0-7]{1,2}|[4-7][0-7]|[1-7])/u
+                );
 
                 if (match) {
-                    const octalDigit = match[2];
-
-                    // \0 is actually not considered an octal
-                    if (match[2] !== "0" || typeof match[3] !== "undefined") {
-                        context.report({ node, message: "Don't use octal: '\\{{octalDigit}}'. Use '\\u....' instead.", data: { octalDigit } });
-                    }
+                    context.report({
+                        node,
+                        messageId: "octalEscapeSequence",
+                        data: { sequence: match[1] }
+                    });
                 }
             }
 

package/lib/rules/no-self-assign.js

@@ -152,13 +152,14 @@ function eachSelfAssignment(left, right, props, report) {
     } else if (
         left.type === "Property" &&
         right.type === "Property" &&
-        !left.computed &&
-        !right.computed &&
         right.kind === "init" &&
-        !right.method &&
-        left.key.name === right.key.name
+        !right.method
     ) {
-        eachSelfAssignment(left.value, right.value, props, report);
+        const leftName = astUtils.getStaticPropertyName(left);
+
+        if (leftName !== null && leftName === astUtils.getStaticPropertyName(right)) {
+            eachSelfAssignment(left.value, right.value, props, report);
+        }
     } else if (
         props &&
         left.type === "MemberExpression" &&

package/lib/rules/no-sequences.js

@@ -105,9 +105,9 @@ module.exports = {
                     }
                 }
 
-                const child = sourceCode.getTokenAfter(node.expressions[0]);
+                const firstCommaToken = sourceCode.getTokenAfter(node.expressions[0], astUtils.isCommaToken);
 
-                context.report({ node, loc: child.loc.start, message: "Unexpected use of comma operator." });
+                context.report({ node, loc: firstCommaToken.loc, message: "Unexpected use of comma operator." });
             }
         };
 

package/lib/rules/no-unsafe-negation.js

@@ -51,7 +51,7 @@ module.exports = {
         },
 
         schema: [],
-        fixable: "code",
+        fixable: null,
         messages: {
             unexpected: "Unexpected negating the left operand of '{{operator}}' operator."
         }
@@ -70,15 +70,7 @@ module.exports = {
                         node,
                         loc: node.left.loc,
                         messageId: "unexpected",
-                        data: { operator: node.operator },
-
-                        fix(fixer) {
-                            const negationToken = sourceCode.getFirstToken(node.left);
-                            const fixRange = [negationToken.range[1], node.range[1]];
-                            const text = sourceCode.text.slice(fixRange[0], fixRange[1]);
-
-                            return fixer.replaceTextRange(fixRange, `(${text})`);
-                        }
+                        data: { operator: node.operator }
                     });
                 }
             }

package/lib/rules/object-curly-spacing.js

@@ -167,7 +167,7 @@ module.exports = {
                 if (options.spaced && !firstSpaced) {
                     reportRequiredBeginningSpace(node, first);
                 }
-                if (!options.spaced && firstSpaced) {
+                if (!options.spaced && firstSpaced && second.type !== "Line") {
                     reportNoBeginningSpace(node, first);
                 }
             }

package/lib/rules/object-shorthand.js

@@ -244,6 +244,7 @@ module.exports = {
             const keyText = sourceCode.text.slice(firstKeyToken.range[0], lastKeyToken.range[1]);
             let keyPrefix = "";
 
+            // key: /* */ () => {}
             if (sourceCode.commentsExistBetween(lastKeyToken, node.value)) {
                 return null;
             }
@@ -255,24 +256,49 @@ module.exports = {
                 keyPrefix += "*";
             }
 
+            const fixRange = [firstKeyToken.range[0], node.range[1]];
+            const methodPrefix = keyPrefix + keyText;
+
             if (node.value.type === "FunctionExpression") {
                 const functionToken = sourceCode.getTokens(node.value).find(token => token.type === "Keyword" && token.value === "function");
                 const tokenBeforeParams = node.value.generator ? sourceCode.getTokenAfter(functionToken) : functionToken;
 
                 return fixer.replaceTextRange(
-                    [firstKeyToken.range[0], node.range[1]],
-                    keyPrefix + keyText + sourceCode.text.slice(tokenBeforeParams.range[1], node.value.range[1])
+                    fixRange,
+                    methodPrefix + sourceCode.text.slice(tokenBeforeParams.range[1], node.value.range[1])
                 );
             }
-            const arrowToken = sourceCode.getTokenBefore(node.value.body, { filter: token => token.value === "=>" });
-            const tokenBeforeArrow = sourceCode.getTokenBefore(arrowToken);
-            const hasParensAroundParameters = tokenBeforeArrow.type === "Punctuator" && tokenBeforeArrow.value === ")";
-            const oldParamText = sourceCode.text.slice(sourceCode.getFirstToken(node.value, node.value.async ? 1 : 0).range[0], tokenBeforeArrow.range[1]);
-            const newParamText = hasParensAroundParameters ? oldParamText : `(${oldParamText})`;
+
+            const arrowToken = sourceCode.getTokenBefore(node.value.body, astUtils.isArrowToken);
+            const fnBody = sourceCode.text.slice(arrowToken.range[1], node.value.range[1]);
+
+            let shouldAddParensAroundParameters = false;
+            let tokenBeforeParams;
+
+            if (node.value.params.length === 0) {
+                tokenBeforeParams = sourceCode.getFirstToken(node.value, astUtils.isOpeningParenToken);
+            } else {
+                tokenBeforeParams = sourceCode.getTokenBefore(node.value.params[0]);
+            }
+
+            if (node.value.params.length === 1) {
+                const hasParen = astUtils.isOpeningParenToken(tokenBeforeParams);
+                const isTokenOutsideNode = tokenBeforeParams.range[0] < node.range[0];
+
+                shouldAddParensAroundParameters = !hasParen || isTokenOutsideNode;
+            }
+
+            const sliceStart = shouldAddParensAroundParameters
+                ? node.value.params[0].range[0]
+                : tokenBeforeParams.range[0];
+            const sliceEnd = sourceCode.getTokenBefore(arrowToken).range[1];
+
+            const oldParamText = sourceCode.text.slice(sliceStart, sliceEnd);
+            const newParamText = shouldAddParensAroundParameters ? `(${oldParamText})` : oldParamText;
 
             return fixer.replaceTextRange(
-                [firstKeyToken.range[0], node.range[1]],
-                keyPrefix + keyText + newParamText + sourceCode.text.slice(arrowToken.range[1], node.value.range[1])
+                fixRange,
+                methodPrefix + newParamText + fnBody
             );
 
         }

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

@@ -0,0 +1,125 @@
+/**
+ * @fileoverview Rule to disallow use of the `RegExp` constructor in favor of regular expression literals
+ * @author Milos Djermanovic
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("./utils/ast-utils");
+const { CALL, CONSTRUCT, ReferenceTracker, findVariable } = require("eslint-utils");
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+/**
+ * Determines whether the given node is a string literal.
+ * @param {ASTNode} node Node to check.
+ * @returns {boolean} True if the node is a string literal.
+ */
+function isStringLiteral(node) {
+    return node.type === "Literal" && typeof node.value === "string";
+}
+
+/**
+ * Determines whether the given node is a template literal without expressions.
+ * @param {ASTNode} node Node to check.
+ * @returns {boolean} True if the node is a template literal without expressions.
+ */
+function isStaticTemplateLiteral(node) {
+    return node.type === "TemplateLiteral" && node.expressions.length === 0;
+}
+
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = {
+    meta: {
+        type: "suggestion",
+
+        docs: {
+            description: "disallow use of the `RegExp` constructor in favor of regular expression literals",
+            category: "Best Practices",
+            recommended: false,
+            url: "https://eslint.org/docs/rules/prefer-regex-literals"
+        },
+
+        schema: [],
+
+        messages: {
+            unexpectedRegExp: "Use a regular expression literal instead of the 'RegExp' constructor."
+        }
+    },
+
+    create(context) {
+
+        /**
+         * Determines whether the given identifier node is a reference to a global variable.
+         * @param {ASTNode} node `Identifier` node to check.
+         * @returns {boolean} True if the identifier is a reference to a global variable.
+         */
+        function isGlobalReference(node) {
+            const scope = context.getScope();
+            const variable = findVariable(scope, node);
+
+            return variable !== null && variable.scope.type === "global" && variable.defs.length === 0;
+        }
+
+        /**
+         * Determines whether the given node is a String.raw`` tagged template expression
+         * with a static template literal.
+         * @param {ASTNode} node Node to check.
+         * @returns {boolean} True if the node is String.raw`` with a static template.
+         */
+        function isStringRawTaggedStaticTemplateLiteral(node) {
+            return node.type === "TaggedTemplateExpression" &&
+                node.tag.type === "MemberExpression" &&
+                node.tag.object.type === "Identifier" &&
+                node.tag.object.name === "String" &&
+                isGlobalReference(node.tag.object) &&
+                astUtils.getStaticPropertyName(node.tag) === "raw" &&
+                isStaticTemplateLiteral(node.quasi);
+        }
+
+        /**
+         * Determines whether the given node is considered to be a static string by the logic of this rule.
+         * @param {ASTNode} node Node to check.
+         * @returns {boolean} True if the node is a static string.
+         */
+        function isStaticString(node) {
+            return isStringLiteral(node) ||
+                isStaticTemplateLiteral(node) ||
+                isStringRawTaggedStaticTemplateLiteral(node);
+        }
+
+        return {
+            Program() {
+                const scope = context.getScope();
+                const tracker = new ReferenceTracker(scope);
+                const traceMap = {
+                    RegExp: {
+                        [CALL]: true,
+                        [CONSTRUCT]: true
+                    }
+                };
+
+                for (const { node } of tracker.iterateGlobalReferences(traceMap)) {
+                    const args = node.arguments;
+
+                    if (
+                        (args.length === 1 || args.length === 2) &&
+                        args.every(isStaticString)
+                    ) {
+                        context.report({ node, messageId: "unexpectedRegExp" });
+                    }
+                }
+            }
+        };
+    }
+};

package/lib/rules/quotes.js

@@ -279,6 +279,12 @@ module.exports = {
                                 description: settings.description
                             },
                             fix(fixer) {
+                                if (quoteOption === "backtick" && astUtils.hasOctalEscapeSequence(rawVal)) {
+
+                                    // An octal escape sequence in a template literal would produce syntax error, even in non-strict mode.
+                                    return null;
+                                }
+
                                 return fixer.replaceText(node, settings.convert(node.raw));
                             }
                         });

package/lib/rules/space-before-function-paren.js

@@ -124,7 +124,18 @@ module.exports = {
                     node,
                     loc: leftToken.loc.end,
                     message: "Unexpected space before function parentheses.",
-                    fix: fixer => fixer.removeRange([leftToken.range[1], rightToken.range[0]])
+                    fix(fixer) {
+                        const comments = sourceCode.getCommentsBefore(rightToken);
+
+                        // Don't fix anything if there's a single line comment between the left and the right token
+                        if (comments.some(comment => comment.type === "Line")) {
+                            return null;
+                        }
+                        return fixer.replaceTextRange(
+                            [leftToken.range[1], rightToken.range[0]],
+                            comments.reduce((text, comment) => text + sourceCode.getText(comment), "")
+                        );
+                    }
                 });
             } else if (!hasSpacing && functionConfig === "always") {
                 context.report({