eslint 6.3.0 → 6.6.0

package/lib/rules/prefer-template.js

@@ -17,7 +17,7 @@ const astUtils = require("./utils/ast-utils");
 
 /**
  * Checks whether or not a given node is a concatenation.
- * @param {ASTNode} node - A node to check.
+ * @param {ASTNode} node A node to check.
  * @returns {boolean} `true` if the node is a concatenation.
  */
 function isConcatenation(node) {
@@ -26,7 +26,7 @@ function isConcatenation(node) {
 
 /**
  * Gets the top binary expression node for concatenation in parents of a given node.
- * @param {ASTNode} node - A node to get.
+ * @param {ASTNode} node A node to get.
  * @returns {ASTNode} the top binary expression node in parents of a given node.
  */
 function getTopConcatBinaryExpression(node) {
@@ -70,7 +70,7 @@ function hasOctalEscapeSequence(node) {
 
 /**
  * Checks whether or not a given binary expression has string literals.
- * @param {ASTNode} node - A node to check.
+ * @param {ASTNode} node A node to check.
  * @returns {boolean} `true` if the node has string literals.
  */
 function hasStringLiteral(node) {
@@ -84,7 +84,7 @@ function hasStringLiteral(node) {
 
 /**
  * Checks whether or not a given binary expression has non string literals.
- * @param {ASTNode} node - A node to check.
+ * @param {ASTNode} node A node to check.
  * @returns {boolean} `true` if the node has non string literals.
  */
 function hasNonStringLiteral(node) {
@@ -242,8 +242,7 @@ module.exports = {
 
         /**
          * Reports if a given node is string concatenation with non string literals.
-         *
-         * @param {ASTNode} node - A node to check.
+         * @param {ASTNode} node A node to check.
          * @returns {void}
          */
         function checkForStringConcat(node) {

package/lib/rules/quote-props.js

@@ -85,7 +85,7 @@ module.exports = {
 
         /**
          * Checks whether a certain string constitutes an ES3 token
-         * @param   {string} tokenStr - The string to be checked.
+         * @param   {string} tokenStr The string to be checked.
          * @returns {boolean} `true` if it is an ES3 token.
          */
         function isKeyword(tokenStr) {

package/lib/rules/quotes.js

@@ -41,7 +41,7 @@ const UNESCAPED_LINEBREAK_PATTERN = new RegExp(String.raw`(^|[^\\])(\\\\)*[${Arr
  * escaping and unescaping as necessary.
  * Only escaping of the minimal set of characters is changed.
  * Note: escaping of newlines when switching from backtick to other quotes is not handled.
- * @param {string} str - A string to convert.
+ * @param {string} str A string to convert.
  * @returns {string} The string with changed quotes.
  * @private
  */
@@ -143,7 +143,6 @@ module.exports = {
          *
          * In both cases, inside of the braces is handled as normal JavaScript.
          * The braces are `JSXExpressionContainer` nodes.
-         *
          * @param {ASTNode} node The Literal node to check.
          * @returns {boolean} True if the node is a part of JSX, false if not.
          * @private
@@ -155,7 +154,7 @@ module.exports = {
         /**
          * Checks whether or not a given node is a directive.
          * The directive is a `ExpressionStatement` which has only a string literal.
-         * @param {ASTNode} node - A node to check.
+         * @param {ASTNode} node A node to check.
          * @returns {boolean} Whether or not the node is a directive.
          * @private
          */
@@ -170,7 +169,7 @@ module.exports = {
         /**
          * Checks whether or not a given node is a part of directive prologues.
          * See also: http://www.ecma-international.org/ecma-262/6.0/#sec-directive-prologues-and-the-use-strict-directive
-         * @param {ASTNode} node - A node to check.
+         * @param {ASTNode} node A node to check.
          * @returns {boolean} Whether or not the node is a part of directive prologues.
          * @private
          */
@@ -198,7 +197,7 @@ module.exports = {
 
         /**
          * Checks whether or not a given node is allowed as non backtick.
-         * @param {ASTNode} node - A node to check.
+         * @param {ASTNode} node A node to check.
          * @returns {boolean} Whether or not the node is allowed as non backtick.
          * @private
          */
@@ -230,7 +229,7 @@ module.exports = {
 
         /**
          * Checks whether or not a given TemplateLiteral node is actually using any of the special features provided by template literal strings.
-         * @param {ASTNode} node - A TemplateLiteral node to check.
+         * @param {ASTNode} node A TemplateLiteral node to check.
          * @returns {boolean} Whether or not the TemplateLiteral node is using any of the special features provided by template literal strings.
          * @private
          */
@@ -279,6 +278,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/radix.js

@@ -20,8 +20,7 @@ const MODE_ALWAYS = "always",
 
 /**
  * Checks whether a given variable is shadowed or not.
- *
- * @param {eslint-scope.Variable} variable - A variable to check.
+ * @param {eslint-scope.Variable} variable A variable to check.
  * @returns {boolean} `true` if the variable is shadowed.
  */
 function isShadowed(variable) {
@@ -30,8 +29,7 @@ function isShadowed(variable) {
 
 /**
  * Checks whether a given node is a MemberExpression of `parseInt` method or not.
- *
- * @param {ASTNode} node - A node to check.
+ * @param {ASTNode} node A node to check.
  * @returns {boolean} `true` if the node is a MemberExpression of `parseInt`
  *      method.
  */
@@ -51,8 +49,7 @@ function isParseIntMethod(node) {
  *
  * - A literal except numbers.
  * - undefined.
- *
- * @param {ASTNode} radix - A node of radix to check.
+ * @param {ASTNode} radix A node of radix to check.
  * @returns {boolean} `true` if the node is valid.
  */
 function isValidRadix(radix) {
@@ -64,8 +61,7 @@ function isValidRadix(radix) {
 
 /**
  * Checks whether a given node is a default value of radix or not.
- *
- * @param {ASTNode} radix - A node of radix to check.
+ * @param {ASTNode} radix A node of radix to check.
  * @returns {boolean} `true` if the node is the literal node of `10`.
  */
 function isDefaultRadix(radix) {
@@ -100,8 +96,7 @@ module.exports = {
         /**
          * Checks the arguments of a given CallExpression node and reports it if it
          * offends this rule.
-         *
-         * @param {ASTNode} node - A CallExpression node to check.
+         * @param {ASTNode} node A CallExpression node to check.
          * @returns {void}
          */
         function checkArguments(node) {

package/lib/rules/require-await.js

@@ -17,8 +17,7 @@ const astUtils = require("./utils/ast-utils");
 
 /**
  * Capitalize the 1st letter of the given text.
- *
- * @param {string} text - The text to capitalize.
+ * @param {string} text The text to capitalize.
  * @returns {string} The text that the 1st letter was capitalized.
  */
 function capitalizeFirstLetter(text) {
@@ -49,7 +48,6 @@ module.exports = {
 
         /**
          * Push the scope info object to the stack.
-         *
          * @returns {void}
          */
         function enterFunction() {
@@ -62,8 +60,7 @@ module.exports = {
         /**
          * Pop the top scope info object from the stack.
          * Also, it reports the function if needed.
-         *
-         * @param {ASTNode} node - The node to report.
+         * @param {ASTNode} node The node to report.
          * @returns {void}
          */
         function exitFunction(node) {

package/lib/rules/require-yield.js

@@ -28,7 +28,7 @@ module.exports = {
 
         /**
          * If the node is a generator function, start counting `yield` keywords.
-         * @param {Node} node - A function node to check.
+         * @param {Node} node A function node to check.
          * @returns {void}
          */
         function beginChecking(node) {
@@ -40,7 +40,7 @@ module.exports = {
         /**
          * If the node is a generator function, end counting `yield` keywords, then
          * reports result.
-         * @param {Node} node - A function node to check.
+         * @param {Node} node A function node to check.
          * @returns {void}
          */
         function endChecking(node) {

package/lib/rules/rest-spread-spacing.js

@@ -39,7 +39,7 @@ module.exports = {
 
         /**
          * Checks whitespace between rest/spread operators and their expressions
-         * @param {ASTNode} node - The node to check
+         * @param {ASTNode} node The node to check
          * @returns {void}
          */
         function checkWhiteSpace(node) {

package/lib/rules/sort-imports.js

@@ -70,8 +70,7 @@ module.exports = {
          * import * as myModule from "my-module.js" --> all
          * import {myMember} from "my-module.js" --> single
          * import {foo, bar} from  "my-module.js" --> multiple
-         *
-         * @param {ASTNode} node - the ImportDeclaration node.
+         * @param {ASTNode} node the ImportDeclaration node.
          * @returns {string} used member parameter style, ["all", "multiple", "single"]
          */
         function usedMemberSyntax(node) {
@@ -90,7 +89,7 @@ module.exports = {
 
         /**
          * Gets the group by member parameter index for given declaration.
-         * @param {ASTNode} node - the ImportDeclaration node.
+         * @param {ASTNode} node the ImportDeclaration node.
          * @returns {number} the declaration group by member index.
          */
         function getMemberParameterGroupIndex(node) {
@@ -99,7 +98,7 @@ module.exports = {
 
         /**
          * Gets the local name of the first imported module.
-         * @param {ASTNode} node - the ImportDeclaration node.
+         * @param {ASTNode} node the ImportDeclaration node.
          * @returns {?string} the local name of the first imported module.
          */
         function getFirstLocalMemberName(node) {

package/lib/rules/sort-keys.js

@@ -23,8 +23,7 @@ const astUtils = require("./utils/ast-utils"),
  *   whether it's a computed property or not.
  * - If the property has a static name, this returns the static name.
  * - Otherwise, this returns null.
- *
- * @param {ASTNode} node - The `Property` node to get.
+ * @param {ASTNode} node The `Property` node to get.
  * @returns {string|null} The property name or null.
  * @private
  */
@@ -43,7 +42,6 @@ function getPropertyName(node) {
  *
  * Postfix `I` is meant insensitive.
  * Postfix `N` is meant natual.
- *
  * @private
  */
 const isValidOrders = {

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

@@ -79,8 +79,7 @@ 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.
+         * @param {Token} token A token to check.
          * @returns {boolean} `true` if the token is an arrow operator.
          */
         function isConflicted(token) {

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({

package/lib/rules/space-in-parens.js

@@ -40,23 +40,28 @@ module.exports = {
                 },
                 additionalProperties: false
             }
-        ]
+        ],
+
+        messages: {
+            missingOpeningSpace: "There must be a space after this paren.",
+            missingClosingSpace: "There must be a space before this paren.",
+            rejectedOpeningSpace: "There should be no space after this paren.",
+            rejectedClosingSpace: "There should be no space before this paren."
+        }
     },
 
     create(context) {
-
-        const MISSING_SPACE_MESSAGE = "There must be a space inside this paren.",
-            REJECTED_SPACE_MESSAGE = "There should be no spaces inside this paren.",
-            ALWAYS = context.options[0] === "always",
+        const ALWAYS = context.options[0] === "always",
             exceptionsArrayOptions = (context.options[1] && context.options[1].exceptions) || [],
             options = {};
+
         let exceptions;
 
         if (exceptionsArrayOptions.length) {
-            options.braceException = exceptionsArrayOptions.indexOf("{}") !== -1;
-            options.bracketException = exceptionsArrayOptions.indexOf("[]") !== -1;
-            options.parenException = exceptionsArrayOptions.indexOf("()") !== -1;
-            options.empty = exceptionsArrayOptions.indexOf("empty") !== -1;
+            options.braceException = exceptionsArrayOptions.includes("{}");
+            options.bracketException = exceptionsArrayOptions.includes("[]");
+            options.parenException = exceptionsArrayOptions.includes("()");
+            options.empty = exceptionsArrayOptions.includes("empty");
         }
 
         /**
@@ -105,7 +110,7 @@ module.exports = {
          * @returns {boolean} True if the token is one of the exceptions for the opener paren
          */
         function isOpenerException(token) {
-            return token.type === "Punctuator" && exceptions.openers.indexOf(token.value) >= 0;
+            return exceptions.openers.includes(token.value);
         }
 
         /**
@@ -114,102 +119,95 @@ module.exports = {
          * @returns {boolean} True if the token is one of the exceptions for the closer paren
          */
         function isCloserException(token) {
-            return token.type === "Punctuator" && exceptions.closers.indexOf(token.value) >= 0;
+            return exceptions.closers.includes(token.value);
         }
 
         /**
-         * Determines if an opener paren should have a missing space after it
-         * @param {Object} left The paren token
-         * @param {Object} right The token after it
-         * @returns {boolean} True if the paren should have a space
+         * Determines if an opening paren is immediately followed by a required space
+         * @param {Object} openingParenToken The paren token
+         * @param {Object} tokenAfterOpeningParen The token after it
+         * @returns {boolean} True if the opening paren is missing a required space
          */
-        function shouldOpenerHaveSpace(left, right) {
-            if (sourceCode.isSpaceBetweenTokens(left, right)) {
+        function openerMissingSpace(openingParenToken, tokenAfterOpeningParen) {
+            if (sourceCode.isSpaceBetweenTokens(openingParenToken, tokenAfterOpeningParen)) {
                 return false;
             }
 
-            if (ALWAYS) {
-                if (astUtils.isClosingParenToken(right)) {
-                    return false;
-                }
-                return !isOpenerException(right);
+            if (!options.empty && astUtils.isClosingParenToken(tokenAfterOpeningParen)) {
+                return false;
             }
-            return isOpenerException(right);
 
+            if (ALWAYS) {
+                return !isOpenerException(tokenAfterOpeningParen);
+            }
+            return isOpenerException(tokenAfterOpeningParen);
         }
 
         /**
-         * Determines if an closer paren should have a missing space after it
-         * @param {Object} left The token before the paren
-         * @param {Object} right The paren token
-         * @returns {boolean} True if the paren should have a space
+         * Determines if an opening paren is immediately followed by a disallowed space
+         * @param {Object} openingParenToken The paren token
+         * @param {Object} tokenAfterOpeningParen The token after it
+         * @returns {boolean} True if the opening paren has a disallowed space
          */
-        function shouldCloserHaveSpace(left, right) {
-            if (astUtils.isOpeningParenToken(left)) {
+        function openerRejectsSpace(openingParenToken, tokenAfterOpeningParen) {
+            if (!astUtils.isTokenOnSameLine(openingParenToken, tokenAfterOpeningParen)) {
                 return false;
             }
 
-            if (sourceCode.isSpaceBetweenTokens(left, right)) {
+            if (tokenAfterOpeningParen.type === "Line") {
                 return false;
             }
 
-            if (ALWAYS) {
-                return !isCloserException(left);
+            if (!sourceCode.isSpaceBetweenTokens(openingParenToken, tokenAfterOpeningParen)) {
+                return false;
             }
-            return isCloserException(left);
 
+            if (ALWAYS) {
+                return isOpenerException(tokenAfterOpeningParen);
+            }
+            return !isOpenerException(tokenAfterOpeningParen);
         }
 
         /**
-         * Determines if an opener paren should not have an existing space after it
-         * @param {Object} left The paren token
-         * @param {Object} right The token after it
-         * @returns {boolean} True if the paren should reject the space
+         * Determines if a closing paren is immediately preceeded by a required space
+         * @param {Object} tokenBeforeClosingParen The token before the paren
+         * @param {Object} closingParenToken The paren token
+         * @returns {boolean} True if the closing paren is missing a required space
          */
-        function shouldOpenerRejectSpace(left, right) {
-            if (right.type === "Line") {
-                return false;
-            }
-
-            if (!astUtils.isTokenOnSameLine(left, right)) {
+        function closerMissingSpace(tokenBeforeClosingParen, closingParenToken) {
+            if (sourceCode.isSpaceBetweenTokens(tokenBeforeClosingParen, closingParenToken)) {
                 return false;
             }
 
-            if (!sourceCode.isSpaceBetweenTokens(left, right)) {
+            if (!options.empty && astUtils.isOpeningParenToken(tokenBeforeClosingParen)) {
                 return false;
             }
 
             if (ALWAYS) {
-                return isOpenerException(right);
+                return !isCloserException(tokenBeforeClosingParen);
             }
-            return !isOpenerException(right);
-
+            return isCloserException(tokenBeforeClosingParen);
         }
 
         /**
-         * Determines if an closer paren should not have an existing space after it
-         * @param {Object} left The token before the paren
-         * @param {Object} right The paren token
-         * @returns {boolean} True if the paren should reject the space
+         * Determines if a closer paren is immediately preceeded by a disallowed space
+         * @param {Object} tokenBeforeClosingParen The token before the paren
+         * @param {Object} closingParenToken The paren token
+         * @returns {boolean} True if the closing paren has a disallowed space
          */
-        function shouldCloserRejectSpace(left, right) {
-            if (astUtils.isOpeningParenToken(left)) {
+        function closerRejectsSpace(tokenBeforeClosingParen, closingParenToken) {
+            if (!astUtils.isTokenOnSameLine(tokenBeforeClosingParen, closingParenToken)) {
                 return false;
             }
 
-            if (!astUtils.isTokenOnSameLine(left, right)) {
-                return false;
-            }
-
-            if (!sourceCode.isSpaceBetweenTokens(left, right)) {
+            if (!sourceCode.isSpaceBetweenTokens(tokenBeforeClosingParen, closingParenToken)) {
                 return false;
             }
 
             if (ALWAYS) {
-                return isCloserException(left);
+                return isCloserException(tokenBeforeClosingParen);
             }
-            return !isCloserException(left);
-
+            return !isCloserException(tokenBeforeClosingParen);
         }
 
         //--------------------------------------------------------------------------
@@ -225,44 +223,53 @@ module.exports = {
                     const prevToken = tokens[i - 1];
                     const nextToken = tokens[i + 1];
 
+                    // if token is not an opening or closing paren token, do nothing
                     if (!astUtils.isOpeningParenToken(token) && !astUtils.isClosingParenToken(token)) {
                         return;
                     }
 
-                    if (token.value === "(" && shouldOpenerHaveSpace(token, nextToken)) {
+                    // if token is an opening paren and is not followed by a required space
+                    if (token.value === "(" && openerMissingSpace(token, nextToken)) {
                         context.report({
                             node,
-                            loc: token.loc.start,
-                            message: MISSING_SPACE_MESSAGE,
+                            loc: token.loc,
+                            messageId: "missingOpeningSpace",
                             fix(fixer) {
                                 return fixer.insertTextAfter(token, " ");
                             }
                         });
-                    } else if (token.value === "(" && shouldOpenerRejectSpace(token, nextToken)) {
+                    }
+
+                    // if token is an opening paren and is followed by a disallowed space
+                    if (token.value === "(" && openerRejectsSpace(token, nextToken)) {
                         context.report({
                             node,
-                            loc: token.loc.start,
-                            message: REJECTED_SPACE_MESSAGE,
+                            loc: { start: token.loc.end, end: nextToken.loc.start },
+                            messageId: "rejectedOpeningSpace",
                             fix(fixer) {
                                 return fixer.removeRange([token.range[1], nextToken.range[0]]);
                             }
                         });
-                    } else if (token.value === ")" && shouldCloserHaveSpace(prevToken, token)) {
+                    }
 
-                        // context.report(node, token.loc.start, MISSING_SPACE_MESSAGE);
+                    // if token is a closing paren and is not preceded by a required space
+                    if (token.value === ")" && closerMissingSpace(prevToken, token)) {
                         context.report({
                             node,
-                            loc: token.loc.start,
-                            message: MISSING_SPACE_MESSAGE,
+                            loc: token.loc,
+                            messageId: "missingClosingSpace",
                             fix(fixer) {
                                 return fixer.insertTextBefore(token, " ");
                             }
                         });
-                    } else if (token.value === ")" && shouldCloserRejectSpace(prevToken, token)) {
+                    }
+
+                    // if token is a closing paren and is preceded by a disallowed space
+                    if (token.value === ")" && closerRejectsSpace(prevToken, token)) {
                         context.report({
                             node,
-                            loc: token.loc.start,
-                            message: REJECTED_SPACE_MESSAGE,
+                            loc: { start: prevToken.loc.end, end: token.loc.start },
+                            messageId: "rejectedClosingSpace",
                             fix(fixer) {
                                 return fixer.removeRange([prevToken.range[1], token.range[0]]);
                             }
@@ -271,6 +278,5 @@ module.exports = {
                 });
             }
         };
-
     }
 };

package/lib/rules/space-infix-ops.js

@@ -41,9 +41,9 @@ module.exports = {
 
         /**
          * Returns the first token which violates the rule
-         * @param {ASTNode} left - The left node of the main node
-         * @param {ASTNode} right - The right node of the main node
-         * @param {string} op - The operator of the main node
+         * @param {ASTNode} left The left node of the main node
+         * @param {ASTNode} right The right node of the main node
+         * @param {string} op The operator of the main node
          * @returns {Object} The violator token or null
          * @private
          */
@@ -61,8 +61,8 @@ module.exports = {
 
         /**
          * Reports an AST node as a rule violation
-         * @param {ASTNode} mainNode - The node to report
-         * @param {Object} culpritToken - The token which has a problem
+         * @param {ASTNode} mainNode The node to report
+         * @param {Object} culpritToken The token which has a problem
          * @returns {void}
          * @private
          */