eslint 5.13.0 → 5.15.1

package/lib/rules/no-var.js

@@ -77,7 +77,7 @@ function isDeclarationInitialized(node) {
     return node.declarations.every(declarator => declarator.init !== null);
 }
 
-const SCOPE_NODE_TYPE = /^(?:Program|BlockStatement|SwitchStatement|ForStatement|ForInStatement|ForOfStatement)$/;
+const SCOPE_NODE_TYPE = /^(?:Program|BlockStatement|SwitchStatement|ForStatement|ForInStatement|ForOfStatement)$/u;
 
 /**
  * Gets the scope node which directly contains a given node.

package/lib/rules/no-warning-comments.js

@@ -47,7 +47,7 @@ module.exports = {
             configuration = context.options[0] || {},
             warningTerms = configuration.terms || ["todo", "fixme", "xxx"],
             location = configuration.location || "start",
-            selfConfigRegEx = /\bno-warning-comments\b/;
+            selfConfigRegEx = /\bno-warning-comments\b/u;
 
         /**
          * Convert a warning term into a RegExp which will match a comment containing that whole word in the specified
@@ -58,7 +58,7 @@ module.exports = {
          * @returns {RegExp} The term converted to a RegExp
          */
         function convertToRegExp(term) {
-            const escaped = term.replace(/[-/\\$^*+?.()|[\]{}]/g, "\\$&");
+            const escaped = term.replace(/[-/\\$^*+?.()|[\]{}]/gu, "\\$&");
             const wordBoundary = "\\b";
             const eitherOrWordBoundary = `|${wordBoundary}`;
             let prefix;
@@ -73,7 +73,7 @@ module.exports = {
              * In these cases, use no bounding match. Same applies for the
              * prefix, handled below.
              */
-            const suffix = /\w$/.test(term) ? "\\b" : "";
+            const suffix = /\w$/u.test(term) ? "\\b" : "";
 
             if (location === "start") {
 
@@ -82,7 +82,7 @@ module.exports = {
                  * there's no need to worry about word boundaries.
                  */
                 prefix = "^\\s*";
-            } else if (/^\w/.test(term)) {
+            } else if (/^\w/u.test(term)) {
                 prefix = wordBoundary;
             } else {
                 prefix = "";
@@ -95,7 +95,7 @@ module.exports = {
                  * ^\s*TERM\b.  This checks the word boundary
                  * at the beginning of the comment.
                  */
-                return new RegExp(prefix + escaped + suffix, "i");
+                return new RegExp(prefix + escaped + suffix, "i"); // eslint-disable-line require-unicode-regexp
             }
 
             /*
@@ -103,7 +103,7 @@ module.exports = {
              * \bTERM\b|\bTERM\b, this checks the entire comment
              * for the term.
              */
-            return new RegExp(prefix + escaped + suffix + eitherOrWordBoundary + term + wordBoundary, "i");
+            return new RegExp(prefix + escaped + suffix + eitherOrWordBoundary + term + wordBoundary, "i"); // eslint-disable-line require-unicode-regexp
         }
 
         const warningRegExps = warningTerms.map(convertToRegExp);

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

@@ -25,10 +25,12 @@ module.exports = {
                 type: "object",
                 properties: {
                     allowAllPropertiesOnSameLine: {
-                        type: "boolean"
+                        type: "boolean",
+                        default: false
                     },
                     allowMultiplePropertiesPerLine: { // Deprecated
-                        type: "boolean"
+                        type: "boolean",
+                        default: false
                     }
                 },
                 additionalProperties: false
@@ -40,7 +42,7 @@ module.exports = {
 
     create(context) {
         const allowSameLine = context.options[0] && (
-            (Boolean(context.options[0].allowAllPropertiesOnSameLine) || Boolean(context.options[0].allowMultiplePropertiesPerLine)) // Deprecated
+            (context.options[0].allowAllPropertiesOnSameLine || context.options[0].allowMultiplePropertiesPerLine /* Deprecated */)
         );
         const errorMessage = allowSameLine
             ? "Object properties must go on a new line if they aren't all on the same line."

package/lib/rules/one-var.js

@@ -32,7 +32,8 @@ module.exports = {
                         type: "object",
                         properties: {
                             separateRequires: {
-                                type: "boolean"
+                                type: "boolean",
+                                default: false
                             },
                             var: {
                                 enum: ["always", "never", "consecutive"]
@@ -76,42 +77,16 @@ module.exports = {
             options.let = { uninitialized: mode, initialized: mode };
             options.const = { uninitialized: mode, initialized: mode };
         } else if (typeof mode === "object") { // options configuration is an object
-            if (Object.prototype.hasOwnProperty.call(mode, "separateRequires")) {
-                options.separateRequires = !!mode.separateRequires;
-            }
-            if (Object.prototype.hasOwnProperty.call(mode, "var")) {
-                options.var = { uninitialized: mode.var, initialized: mode.var };
-            }
-            if (Object.prototype.hasOwnProperty.call(mode, "let")) {
-                options.let = { uninitialized: mode.let, initialized: mode.let };
-            }
-            if (Object.prototype.hasOwnProperty.call(mode, "const")) {
-                options.const = { uninitialized: mode.const, initialized: mode.const };
-            }
+            options.separateRequires = mode.separateRequires;
+            options.var = { uninitialized: mode.var, initialized: mode.var };
+            options.let = { uninitialized: mode.let, initialized: mode.let };
+            options.const = { uninitialized: mode.const, initialized: mode.const };
             if (Object.prototype.hasOwnProperty.call(mode, "uninitialized")) {
-                if (!options.var) {
-                    options.var = {};
-                }
-                if (!options.let) {
-                    options.let = {};
-                }
-                if (!options.const) {
-                    options.const = {};
-                }
                 options.var.uninitialized = mode.uninitialized;
                 options.let.uninitialized = mode.uninitialized;
                 options.const.uninitialized = mode.uninitialized;
             }
             if (Object.prototype.hasOwnProperty.call(mode, "initialized")) {
-                if (!options.var) {
-                    options.var = {};
-                }
-                if (!options.let) {
-                    options.let = {};
-                }
-                if (!options.const) {
-                    options.const = {};
-                }
                 options.var.initialized = mode.initialized;
                 options.let.initialized = mode.initialized;
                 options.const.initialized = mode.initialized;
@@ -257,7 +232,9 @@ module.exports = {
 
             if (currentOptions.uninitialized === MODE_ALWAYS && currentOptions.initialized === MODE_ALWAYS) {
                 if (currentScope.uninitialized || currentScope.initialized) {
-                    return false;
+                    if (!hasRequires) {
+                        return false;
+                    }
                 }
             }
 
@@ -268,7 +245,9 @@ module.exports = {
             }
             if (declarationCounts.initialized > 0) {
                 if (currentOptions.initialized === MODE_ALWAYS && currentScope.initialized) {
-                    return false;
+                    if (!hasRequires) {
+                        return false;
+                    }
                 }
             }
             if (currentScope.required && hasRequires) {
@@ -340,7 +319,11 @@ module.exports = {
                  *      y`
                  *      ^ afterComma
                  */
-                if (afterComma.loc.start.line > tokenAfterDeclarator.loc.end.line || afterComma.type === "Line" || afterComma.type === "Block") {
+                if (
+                    afterComma.loc.start.line > tokenAfterDeclarator.loc.end.line ||
+                    afterComma.type === "Line" ||
+                    afterComma.type === "Block"
+                ) {
                     let lastComment = afterComma;
 
                     while (lastComment.type === "Line" || lastComment.type === "Block") {
@@ -349,7 +332,7 @@ module.exports = {
 
                     return fixer.replaceTextRange(
                         [tokenAfterDeclarator.range[0], lastComment.range[0]],
-                        `;\n${sourceCode.text.slice(tokenAfterDeclarator.range[1], lastComment.range[0])}\n${declaration.kind} `
+                        `;${sourceCode.text.slice(tokenAfterDeclarator.range[1], lastComment.range[0])}${declaration.kind} `
                     );
                 }
 

package/lib/rules/padded-blocks.js

@@ -5,6 +5,12 @@
 
 "use strict";
 
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("../util/ast-utils");
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -45,32 +51,45 @@ module.exports = {
                         minProperties: 1
                     }
                 ]
+            },
+            {
+                type: "object",
+                properties: {
+                    allowSingleLineBlocks: {
+                        type: "boolean"
+                    }
+                }
             }
         ]
     },
 
     create(context) {
         const options = {};
-        const config = context.options[0] || "always";
+        const typeOptions = context.options[0] || "always";
+        const exceptOptions = context.options[1] || {};
 
-        if (typeof config === "string") {
-            const shouldHavePadding = config === "always";
+        if (typeof typeOptions === "string") {
+            const shouldHavePadding = typeOptions === "always";
 
             options.blocks = shouldHavePadding;
             options.switches = shouldHavePadding;
             options.classes = shouldHavePadding;
         } else {
-            if (Object.prototype.hasOwnProperty.call(config, "blocks")) {
-                options.blocks = config.blocks === "always";
+            if (Object.prototype.hasOwnProperty.call(typeOptions, "blocks")) {
+                options.blocks = typeOptions.blocks === "always";
             }
-            if (Object.prototype.hasOwnProperty.call(config, "switches")) {
-                options.switches = config.switches === "always";
+            if (Object.prototype.hasOwnProperty.call(typeOptions, "switches")) {
+                options.switches = typeOptions.switches === "always";
             }
-            if (Object.prototype.hasOwnProperty.call(config, "classes")) {
-                options.classes = config.classes === "always";
+            if (Object.prototype.hasOwnProperty.call(typeOptions, "classes")) {
+                options.classes = typeOptions.classes === "always";
             }
         }
 
+        if (Object.prototype.hasOwnProperty.call(exceptOptions, "allowSingleLineBlocks")) {
+            options.allowSingleLineBlocks = exceptOptions.allowSingleLineBlocks === true;
+        }
+
         const ALWAYS_MESSAGE = "Block must be padded by blank lines.",
             NEVER_MESSAGE = "Block must not be padded by blank lines.";
 
@@ -177,6 +196,10 @@ module.exports = {
                 blockHasTopPadding = isPaddingBetweenTokens(tokenBeforeFirst, firstBlockToken),
                 blockHasBottomPadding = isPaddingBetweenTokens(lastBlockToken, tokenAfterLast);
 
+            if (options.allowSingleLineBlocks && astUtils.isTokenOnSameLine(tokenBeforeFirst, tokenAfterLast)) {
+                return;
+            }
+
             if (requirePaddingFor(node)) {
                 if (!blockHasTopPadding) {
                     context.report({

package/lib/rules/padding-line-between-statements.js

@@ -17,10 +17,11 @@ const astUtils = require("../util/ast-utils");
 
 const LT = `[${Array.from(astUtils.LINEBREAKS).join("")}]`;
 const PADDING_LINE_SEQUENCE = new RegExp(
-    String.raw`^(\s*?${LT})\s*${LT}(\s*;?)$`
+    String.raw`^(\s*?${LT})\s*${LT}(\s*;?)$`,
+    "u"
 );
-const CJS_EXPORT = /^(?:module\s*\.\s*)?exports(?:\s*\.|\s*\[|$)/;
-const CJS_IMPORT = /^require\(/;
+const CJS_EXPORT = /^(?:module\s*\.\s*)?exports(?:\s*\.|\s*\[|$)/u;
+const CJS_IMPORT = /^require\(/u;
 
 /**
  * Creates tester which check if a node starts with specific keyword.

package/lib/rules/prefer-arrow-callback.js

@@ -146,10 +146,12 @@ module.exports = {
                 type: "object",
                 properties: {
                     allowNamedFunctions: {
-                        type: "boolean"
+                        type: "boolean",
+                        default: false
                     },
                     allowUnboundThis: {
-                        type: "boolean"
+                        type: "boolean",
+                        default: true
                     }
                 },
                 additionalProperties: false

package/lib/rules/prefer-const.js

@@ -11,9 +11,9 @@ const astUtils = require("../util/ast-utils");
 // Helpers
 //------------------------------------------------------------------------------
 
-const PATTERN_TYPE = /^(?:.+?Pattern|RestElement|SpreadProperty|ExperimentalRestProperty|Property)$/;
-const DECLARATION_HOST_TYPE = /^(?:Program|BlockStatement|SwitchCase)$/;
-const DESTRUCTURING_HOST_TYPE = /^(?:VariableDeclarator|AssignmentExpression)$/;
+const PATTERN_TYPE = /^(?:.+?Pattern|RestElement|SpreadProperty|ExperimentalRestProperty|Property)$/u;
+const DECLARATION_HOST_TYPE = /^(?:Program|BlockStatement|SwitchCase)$/u;
+const DESTRUCTURING_HOST_TYPE = /^(?:VariableDeclarator|AssignmentExpression)$/u;
 
 /**
  * Checks whether a given node is located at `ForStatement.init` or not.
@@ -345,8 +345,8 @@ module.exports = {
             {
                 type: "object",
                 properties: {
-                    destructuring: { enum: ["any", "all"] },
-                    ignoreReadBeforeAssign: { type: "boolean" }
+                    destructuring: { enum: ["any", "all"], default: "any" },
+                    ignoreReadBeforeAssign: { type: "boolean", default: false }
                 },
                 additionalProperties: false
             }

package/lib/rules/prefer-destructuring.js

@@ -19,6 +19,8 @@ module.exports = {
             url: "https://eslint.org/docs/rules/prefer-destructuring"
         },
 
+        fixable: "code",
+
         schema: [
             {
 
@@ -130,10 +132,55 @@ module.exports = {
          *
          * @param {ASTNode} reportNode the node to report
          * @param {string} type the type of destructuring that should have been done
+         * @param {Function|null} fix the fix function or null to pass to context.report
          * @returns {void}
          */
-        function report(reportNode, type) {
-            context.report({ node: reportNode, message: "Use {{type}} destructuring.", data: { type } });
+        function report(reportNode, type, fix) {
+            context.report({
+                node: reportNode,
+                message: "Use {{type}} destructuring.",
+                data: { type },
+                fix
+            });
+        }
+
+        /**
+         * Determines if a node should be fixed into object destructuring
+         *
+         * The fixer only fixes the simplest case of object destructuring,
+         * like: `let x = a.x`;
+         *
+         * Assignment expression is not fixed.
+         * Array destructuring is not fixed.
+         * Renamed property is not fixed.
+         *
+         * @param {ASTNode} node the the node to evaluate
+         * @returns {boolean} whether or not the node should be fixed
+         */
+        function shouldFix(node) {
+            return node.type === "VariableDeclarator" &&
+                node.id.type === "Identifier" &&
+                node.init.type === "MemberExpression" &&
+                node.id.name === node.init.property.name;
+        }
+
+        /**
+         * Fix a node into object destructuring.
+         * This function only handles the simplest case of object destructuring,
+         * see {@link shouldFix}.
+         *
+         * @param {SourceCodeFixer} fixer the fixer object
+         * @param {ASTNode} node the node to be fixed.
+         * @returns {Object} a fix for the node
+         */
+        function fixIntoObjectDestructuring(fixer, node) {
+            const rightNode = node.init;
+            const sourceCode = context.getSourceCode();
+
+            return fixer.replaceText(
+                node,
+                `{${rightNode.property.name}} = ${sourceCode.getText(rightNode.object)}`
+            );
         }
 
         /**
@@ -155,13 +202,17 @@ module.exports = {
 
             if (isArrayIndexAccess(rightNode)) {
                 if (shouldCheck(reportNode.type, "array")) {
-                    report(reportNode, "array");
+                    report(reportNode, "array", null);
                 }
                 return;
             }
 
+            const fix = shouldFix(reportNode)
+                ? fixer => fixIntoObjectDestructuring(fixer, reportNode)
+                : null;
+
             if (shouldCheck(reportNode.type, "object") && enforceForRenamedProperties) {
-                report(reportNode, "object");
+                report(reportNode, "object", fix);
                 return;
             }
 
@@ -172,7 +223,7 @@ module.exports = {
                     (property.type === "Literal" && leftNode.name === property.value) ||
                     (property.type === "Identifier" && leftNode.name === property.name && !rightNode.computed)
                 ) {
-                    report(reportNode, "object");
+                    report(reportNode, "object", fix);
                 }
             }
         }

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

@@ -0,0 +1,123 @@
+/**
+ * @fileoverview Rule to enforce requiring named capture groups in regular expression.
+ * @author Pig Fang <https://github.com/g-plane>
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const {
+    CALL,
+    CONSTRUCT,
+    ReferenceTracker,
+    getStringIfConstant
+} = require("eslint-utils");
+const regexpp = require("regexpp");
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+const parser = new regexpp.RegExpParser();
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = {
+    meta: {
+        type: "suggestion",
+
+        docs: {
+            description: "enforce using named capture group in regular expression",
+            category: "Best Practices",
+            recommended: false,
+            url: "https://eslint.org/docs/rules/prefer-named-capture-group"
+        },
+
+        schema: [],
+
+        messages: {
+            required: "Capture group '{{group}}' should be converted to a named or non-capturing group."
+        }
+    },
+
+    create(context) {
+
+        /**
+         * Function to check regular expression.
+         *
+         * @param {string} regex The regular expression to be check.
+         * @param {ASTNode} node AST node which contains regular expression.
+         * @param {boolean} uFlag Flag indicates whether unicode mode is enabled or not.
+         * @returns {void}
+         */
+        function checkRegex(regex, node, uFlag) {
+            let ast;
+
+            try {
+                ast = parser.parsePattern(regex, 0, regex.length, uFlag);
+            } catch (_) {
+
+                // ignore regex syntax errors
+                return;
+            }
+
+            regexpp.visitRegExpAST(ast, {
+                onCapturingGroupEnter(group) {
+                    if (!group.name) {
+                        const locNode = node.type === "Literal" ? node : node.arguments[0];
+
+                        context.report({
+                            node,
+                            messageId: "required",
+                            loc: {
+                                start: {
+                                    line: locNode.loc.start.line,
+                                    column: locNode.loc.start.column + group.start + 1
+                                },
+                                end: {
+                                    line: locNode.loc.start.line,
+                                    column: locNode.loc.start.column + group.end + 1
+                                }
+                            },
+                            data: {
+                                group: group.raw
+                            }
+                        });
+                    }
+                }
+            });
+        }
+
+        return {
+            Literal(node) {
+                if (node.regex) {
+                    checkRegex(node.regex.pattern, node, node.regex.flags.includes("u"));
+                }
+            },
+            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 regex = getStringIfConstant(node.arguments[0]);
+                    const flags = getStringIfConstant(node.arguments[1]);
+
+                    if (regex) {
+                        checkRegex(regex, node, flags && flags.includes("u"));
+                    }
+                }
+            }
+        };
+    }
+};

package/lib/rules/prefer-object-spread.js

@@ -14,7 +14,7 @@ const {
     isParenthesised
 } = require("../util/ast-utils");
 
-const ANY_SPACE = /\s/;
+const ANY_SPACE = /\s/u;
 
 /**
  * Helper that checks if the Object.assign call has array spread

package/lib/rules/prefer-promise-reject-errors.js

@@ -27,7 +27,7 @@ module.exports = {
             {
                 type: "object",
                 properties: {
-                    allowEmptyReject: { type: "boolean" }
+                    allowEmptyReject: { type: "boolean", default: false }
                 },
                 additionalProperties: false
             }

package/lib/rules/prefer-spread.js

@@ -59,7 +59,7 @@ module.exports = {
         },
 
         schema: [],
-        fixable: "code"
+        fixable: null
     },
 
     create(context) {
@@ -78,18 +78,7 @@ module.exports = {
                 if (isValidThisArg(expectedThis, thisArg, sourceCode)) {
                     context.report({
                         node,
-                        message: "Use the spread operator instead of '.apply()'.",
-                        fix(fixer) {
-                            if (expectedThis && expectedThis.type !== "Identifier") {
-
-                                // Don't fix cases where the `this` value could be a computed expression.
-                                return null;
-                            }
-
-                            const propertyDot = sourceCode.getFirstTokenBetween(applied, node.callee.property, token => token.value === ".");
-
-                            return fixer.replaceTextRange([propertyDot.range[0], node.range[1]], `(...${sourceCode.getText(node.arguments[1])})`);
-                        }
+                        message: "Use the spread operator instead of '.apply()'."
                     });
                 }
             }

package/lib/rules/prefer-template.js

@@ -52,7 +52,7 @@ function isOctalEscapeSequence(node) {
         return false;
     }
 
-    const match = node.raw.match(/^([^\\]|\\[^0-7])*\\([0-7]{1,3})/);
+    const match = node.raw.match(/^([^\\]|\\[^0-7])*\\([0-7]{1,3})/u);
 
     if (match) {
 
@@ -187,14 +187,14 @@ module.exports = {
                  * for some reason, don't add another backslash, because that would change the meaning of the code (it would cause
                  * an actual backslash character to appear before the dollar sign).
                  */
-                return `\`${currentNode.raw.slice(1, -1).replace(/\\*(\${|`)/g, matched => {
+                return `\`${currentNode.raw.slice(1, -1).replace(/\\*(\$\{|`)/gu, matched => {
                     if (matched.lastIndexOf("\\") % 2) {
                         return `\\${matched}`;
                     }
                     return matched;
 
                 // Unescape any quotes that appear in the original Literal that no longer need to be escaped.
-                }).replace(new RegExp(`\\\\${currentNode.raw[0]}`, "g"), currentNode.raw[0])}\``;
+                }).replace(new RegExp(`\\\\${currentNode.raw[0]}`, "gu"), currentNode.raw[0])}\``;
             }
 
             if (currentNode.type === "TemplateLiteral") {

package/lib/rules/quotes.js

@@ -34,7 +34,7 @@ const QUOTE_SETTINGS = {
 };
 
 // An unescaped newline is a newline preceded by an even number of backslashes.
-const UNESCAPED_LINEBREAK_PATTERN = new RegExp(String.raw`(^|[^\\])(\\\\)*[${Array.from(astUtils.LINEBREAKS).join("")}]`);
+const UNESCAPED_LINEBREAK_PATTERN = new RegExp(String.raw`(^|[^\\])(\\\\)*[${Array.from(astUtils.LINEBREAKS).join("")}]`, "u");
 
 /**
  * Switches quoting of javascript string between ' " and `
@@ -54,7 +54,7 @@ QUOTE_SETTINGS.backtick.convert = function(str) {
     if (newQuote === oldQuote) {
         return str;
     }
-    return newQuote + str.slice(1, -1).replace(/\\(\${|\r\n?|\n|.)|["'`]|\${|(\r\n?|\n)/g, (match, escaped, newline) => {
+    return newQuote + str.slice(1, -1).replace(/\\(\$\{|\r\n?|\n|.)|["'`]|\$\{|(\r\n?|\n)/gu, (match, escaped, newline) => {
         if (escaped === oldQuote || oldQuote === "`" && escaped === "${") {
             return escaped; // unescape
         }