eslint 6.5.1 → 6.7.2

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

@@ -10,8 +10,7 @@
 
 /**
  * Checks whether a given array of statements is a single call of `super`.
- *
- * @param {ASTNode[]} body - An array of statements to check.
+ * @param {ASTNode[]} body An array of statements to check.
  * @returns {boolean} `true` if the body is a single call of `super`.
  */
 function isSingleSuperCall(body) {
@@ -26,8 +25,7 @@ function isSingleSuperCall(body) {
 /**
  * Checks whether a given node is a pattern which doesn't have any side effects.
  * Default parameters and Destructuring parameters can have side effects.
- *
- * @param {ASTNode} node - A pattern node.
+ * @param {ASTNode} node A pattern node.
  * @returns {boolean} `true` if the node doesn't have any side effects.
  */
 function isSimple(node) {
@@ -37,8 +35,7 @@ function isSimple(node) {
 /**
  * Checks whether a given array of expressions is `...arguments` or not.
  * `super(...arguments)` passes all arguments through.
- *
- * @param {ASTNode[]} superArgs - An array of expressions to check.
+ * @param {ASTNode[]} superArgs An array of expressions to check.
  * @returns {boolean} `true` if the superArgs is `...arguments`.
  */
 function isSpreadArguments(superArgs) {
@@ -52,9 +49,8 @@ function isSpreadArguments(superArgs) {
 
 /**
  * Checks whether given 2 nodes are identifiers which have the same name or not.
- *
- * @param {ASTNode} ctorParam - A node to check.
- * @param {ASTNode} superArg - A node to check.
+ * @param {ASTNode} ctorParam A node to check.
+ * @param {ASTNode} superArg A node to check.
  * @returns {boolean} `true` if the nodes are identifiers which have the same
  *      name.
  */
@@ -68,9 +64,8 @@ function isValidIdentifierPair(ctorParam, superArg) {
 
 /**
  * Checks whether given 2 nodes are a rest/spread pair which has the same values.
- *
- * @param {ASTNode} ctorParam - A node to check.
- * @param {ASTNode} superArg - A node to check.
+ * @param {ASTNode} ctorParam A node to check.
+ * @param {ASTNode} superArg A node to check.
  * @returns {boolean} `true` if the nodes are a rest/spread pair which has the
  *      same values.
  */
@@ -84,9 +79,8 @@ function isValidRestSpreadPair(ctorParam, superArg) {
 
 /**
  * Checks whether given 2 nodes have the same value or not.
- *
- * @param {ASTNode} ctorParam - A node to check.
- * @param {ASTNode} superArg - A node to check.
+ * @param {ASTNode} ctorParam A node to check.
+ * @param {ASTNode} superArg A node to check.
  * @returns {boolean} `true` if the nodes have the same value or not.
  */
 function isValidPair(ctorParam, superArg) {
@@ -99,9 +93,8 @@ function isValidPair(ctorParam, superArg) {
 /**
  * Checks whether the parameters of a constructor and the arguments of `super()`
  * have the same values or not.
- *
- * @param {ASTNode} ctorParams - The parameters of a constructor to check.
- * @param {ASTNode} superArgs - The arguments of `super()` to check.
+ * @param {ASTNode} ctorParams The parameters of a constructor to check.
+ * @param {ASTNode} superArgs The arguments of `super()` to check.
  * @returns {boolean} `true` if those have the same values.
  */
 function isPassingThrough(ctorParams, superArgs) {
@@ -120,9 +113,8 @@ function isPassingThrough(ctorParams, superArgs) {
 
 /**
  * Checks whether the constructor body is a redundant super call.
- *
- * @param {Array} body - constructor body content.
- * @param {Array} ctorParams - The params to check against super call.
+ * @param {Array} body constructor body content.
+ * @param {Array} ctorParams The params to check against super call.
  * @returns {boolean} true if the construtor body is redundant
  */
 function isRedundantSuperCall(body, ctorParams) {
@@ -158,7 +150,7 @@ module.exports = {
 
         /**
          * Checks whether a node is a redundant constructor
-         * @param {ASTNode} node - node to check
+         * @param {ASTNode} node node to check
          * @returns {void}
          */
         function checkForConstructor(node) {

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

@@ -85,7 +85,14 @@ module.exports = {
             description: "disallow unnecessary escape characters",
             category: "Best Practices",
             recommended: true,
-            url: "https://eslint.org/docs/rules/no-useless-escape"
+            url: "https://eslint.org/docs/rules/no-useless-escape",
+            suggestion: true
+        },
+
+        messages: {
+            unnecessaryEscape: "Unnecessary escape character: \\{{character}}.",
+            removeEscape: "Remove the `\\`. This maintains the current functionality.",
+            escapeBackslash: "Replace the `\\` with `\\\\` to include the actual backslash character."
         },
 
         schema: []
@@ -103,6 +110,8 @@ module.exports = {
          */
         function report(node, startOffset, character) {
             const start = sourceCode.getLocFromIndex(sourceCode.getIndexFromLoc(node.loc.start) + startOffset);
+            const rangeStart = sourceCode.getIndexFromLoc(node.loc.start) + startOffset;
+            const range = [rangeStart, rangeStart + 1];
 
             context.report({
                 node,
@@ -110,17 +119,30 @@ module.exports = {
                     start,
                     end: { line: start.line, column: start.column + 1 }
                 },
-                message: "Unnecessary escape character: \\{{character}}.",
-                data: { character }
+                messageId: "unnecessaryEscape",
+                data: { character },
+                suggest: [
+                    {
+                        messageId: "removeEscape",
+                        fix(fixer) {
+                            return fixer.removeRange(range);
+                        }
+                    },
+                    {
+                        messageId: "escapeBackslash",
+                        fix(fixer) {
+                            return fixer.insertTextBeforeRange(range, "\\");
+                        }
+                    }
+                ]
             });
         }
 
         /**
          * Checks if the escape character in given string slice is unnecessary.
-         *
          * @private
-         * @param {ASTNode} node - node to validate.
-         * @param {string} match - string slice to validate.
+         * @param {ASTNode} node node to validate.
+         * @param {string} match string slice to validate.
          * @returns {void}
          */
         function validateString(node, match) {
@@ -156,8 +178,7 @@ module.exports = {
 
         /**
          * Checks if a node has an escape.
-         *
-         * @param {ASTNode} node - node to check.
+         * @param {ASTNode} node node to check.
          * @returns {void}
          */
         function check(node) {

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

@@ -48,10 +48,10 @@ module.exports = {
 
         /**
          * Reports error for unnecessarily renamed assignments
-         * @param {ASTNode} node - node to report
-         * @param {ASTNode} initial - node with initial name value
-         * @param {ASTNode} result - node with new name value
-         * @param {string} type - the type of the offending node
+         * @param {ASTNode} node node to report
+         * @param {ASTNode} initial node with initial name value
+         * @param {ASTNode} result node with new name value
+         * @param {string} type the type of the offending node
          * @returns {void}
          */
         function reportError(node, initial, result, type) {
@@ -83,7 +83,7 @@ module.exports = {
 
         /**
          * Checks whether a destructured assignment is unnecessarily renamed
-         * @param {ASTNode} node - node to check
+         * @param {ASTNode} node node to check
          * @returns {void}
          */
         function checkDestructured(node) {
@@ -120,7 +120,7 @@ module.exports = {
 
         /**
          * Checks whether an import is unnecessarily renamed
-         * @param {ASTNode} node - node to check
+         * @param {ASTNode} node node to check
          * @returns {void}
          */
         function checkImport(node) {
@@ -136,7 +136,7 @@ module.exports = {
 
         /**
          * Checks whether an export is unnecessarily renamed
-         * @param {ASTNode} node - node to check
+         * @param {ASTNode} node node to check
          * @returns {void}
          */
         function checkExport(node) {

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

@@ -17,9 +17,8 @@ const astUtils = require("./utils/ast-utils"),
 
 /**
  * Removes the given element from the array.
- *
- * @param {Array} array - The source array to remove.
- * @param {any} element - The target item to remove.
+ * @param {Array} array The source array to remove.
+ * @param {any} element The target item to remove.
  * @returns {void}
  */
 function remove(array, element) {
@@ -32,8 +31,7 @@ function remove(array, element) {
 
 /**
  * Checks whether it can remove the given return statement or not.
- *
- * @param {ASTNode} node - The return statement node to check.
+ * @param {ASTNode} node The return statement node to check.
  * @returns {boolean} `true` if the node is removeable.
  */
 function isRemovable(node) {
@@ -42,8 +40,7 @@ function isRemovable(node) {
 
 /**
  * Checks whether the given return statement is in a `finally` block or not.
- *
- * @param {ASTNode} node - The return statement node to check.
+ * @param {ASTNode} node The return statement node to check.
  * @returns {boolean} `true` if the node is in a `finally` block.
  */
 function isInFinally(node) {
@@ -87,8 +84,7 @@ module.exports = {
 
         /**
          * Checks whether the given segment is terminated by a return statement or not.
-         *
-         * @param {CodePathSegment} segment - The segment to check.
+         * @param {CodePathSegment} segment The segment to check.
          * @returns {boolean} `true` if the segment is terminated by a return statement, or if it's still a part of unreachable.
          */
         function isReturned(segment) {
@@ -110,9 +106,8 @@ module.exports = {
          *
          * This behavior would simulate code paths for the case that the return
          * statement does not exist.
-         *
-         * @param {ASTNode[]} uselessReturns - The collected return statements.
-         * @param {CodePathSegment[]} prevSegments - The previous segments to traverse.
+         * @param {ASTNode[]} uselessReturns The collected return statements.
+         * @param {CodePathSegment[]} prevSegments The previous segments to traverse.
          * @param {WeakSet<CodePathSegment>} [providedTraversedSegments] A set of segments that have already been traversed in this call
          * @returns {ASTNode[]} `uselessReturns`.
          */
@@ -152,8 +147,7 @@ module.exports = {
          *
          * This behavior would simulate code paths for the case that the return
          * statement does not exist.
-         *
-         * @param {CodePathSegment} segment - The segment to get return statements.
+         * @param {CodePathSegment} segment The segment to get return statements.
          * @returns {void}
          */
         function markReturnStatementsOnSegmentAsUsed(segment) {
@@ -184,7 +178,6 @@ module.exports = {
          * - FunctionDeclarations are always executed whether it's returned or not.
          * - BlockStatements do nothing.
          * - BreakStatements go the next merely.
-         *
          * @returns {void}
          */
         function markReturnStatementsOnCurrentSegmentsAsUsed() {

package/lib/rules/no-var.js

@@ -27,8 +27,7 @@ function isGlobal(variable) {
 /**
  * Finds the nearest function scope or global scope walking up the scope
  * hierarchy.
- *
- * @param {eslint-scope.Scope} scope - The scope to traverse.
+ * @param {eslint-scope.Scope} scope The scope to traverse.
  * @returns {eslint-scope.Scope} a function scope or global scope containing the given
  *      scope.
  */
@@ -44,8 +43,7 @@ function getEnclosingFunctionScope(scope) {
 /**
  * Checks whether the given variable has any references from a more specific
  * function expression (i.e. a closure).
- *
- * @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 used from a closure.
  */
 function isReferencedInClosure(variable) {
@@ -57,8 +55,7 @@ function isReferencedInClosure(variable) {
 
 /**
  * Checks whether the given node is the assignee of a loop.
- *
- * @param {ASTNode} node - A VariableDeclaration node to check.
+ * @param {ASTNode} node A VariableDeclaration node to check.
  * @returns {boolean} `true` if the declaration is assigned as part of loop
  *      iteration.
  */
@@ -69,8 +66,7 @@ function isLoopAssignee(node) {
 
 /**
  * Checks whether the given variable declaration is immediately initialized.
- *
- * @param {ASTNode} node - A VariableDeclaration node to check.
+ * @param {ASTNode} node A VariableDeclaration node to check.
  * @returns {boolean} `true` if the declaration has an initializer.
  */
 function isDeclarationInitialized(node) {
@@ -81,8 +77,7 @@ const SCOPE_NODE_TYPE = /^(?:Program|BlockStatement|SwitchStatement|ForStatement
 
 /**
  * Gets the scope node which directly contains a given node.
- *
- * @param {ASTNode} node - A node to get. This is a `VariableDeclaration` or
+ * @param {ASTNode} node A node to get. This is a `VariableDeclaration` or
  *      an `Identifier`.
  * @returns {ASTNode} A scope node. This is one of `Program`, `BlockStatement`,
  *      `SwitchStatement`, `ForStatement`, `ForInStatement`, and
@@ -101,8 +96,7 @@ function getScopeNode(node) {
 
 /**
  * Checks whether a given variable is redeclared 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 redeclared.
  */
 function isRedeclared(variable) {
@@ -111,8 +105,7 @@ function isRedeclared(variable) {
 
 /**
  * Checks whether a given variable is used from outside of the specified scope.
- *
- * @param {ASTNode} scopeNode - A scope node to check.
+ * @param {ASTNode} scopeNode A scope node to check.
  * @returns {Function} The predicate function which checks whether a given
  *      variable is used from outside of the specified scope.
  */
@@ -120,8 +113,7 @@ function isUsedFromOutsideOf(scopeNode) {
 
     /**
      * Checks whether a given reference is inside of the specified scope or not.
-     *
-     * @param {eslint-scope.Reference} reference - A reference to check.
+     * @param {eslint-scope.Reference} reference A reference to check.
      * @returns {boolean} `true` if the reference is inside of the specified
      *      scope.
      */
@@ -145,8 +137,7 @@ function isUsedFromOutsideOf(scopeNode) {
  * - if a reference is before the declarator. E.g. (var a = b, b = 1;)(var {a = b, b} = {};)
  * - if a reference is in the expression of their default value.  E.g. (var {a = a} = {};)
  * - if a reference is in the expression of their initializer.  E.g. (var a = a;)
- *
- * @param {ASTNode} node - The initializer node of VariableDeclarator.
+ * @param {ASTNode} node The initializer node of VariableDeclarator.
  * @returns {Function} The predicate function.
  * @private
  */
@@ -177,7 +168,6 @@ function hasReferenceInTDZ(node) {
 /**
  * Checks whether a given variable has name that is allowed for 'var' declarations,
  * but disallowed for `let` declarations.
- *
  * @param {eslint-scope.Variable} variable The variable to check.
  * @returns {boolean} `true` if the variable has a disallowed name.
  */
@@ -209,8 +199,7 @@ module.exports = {
 
         /**
          * Checks whether the variables which are defined by the given declarator node have their references in TDZ.
-         *
-         * @param {ASTNode} declarator - The VariableDeclarator node to check.
+         * @param {ASTNode} declarator The VariableDeclarator node to check.
          * @returns {boolean} `true` if one of the variables which are defined by the given declarator node have their references in TDZ.
          */
         function hasSelfReferenceInTDZ(declarator) {
@@ -271,8 +260,7 @@ module.exports = {
          * the implementation simple, we only convert `var` to `let` within
          * loops when the variable is a loop assignee or the declaration has an
          * initializer.
-         *
-         * @param {ASTNode} node - A variable declaration node to check.
+         * @param {ASTNode} node A variable declaration node to check.
          * @returns {boolean} `true` if it can fix the node.
          */
         function canFix(node) {
@@ -313,8 +301,7 @@ module.exports = {
 
         /**
          * Reports a given variable declaration node.
-         *
-         * @param {ASTNode} node - A variable declaration node to report.
+         * @param {ASTNode} node A variable declaration node to report.
          * @returns {void}
          */
         function report(node) {

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

@@ -54,7 +54,6 @@ module.exports = {
          * Convert a warning term into a RegExp which will match a comment containing that whole word in the specified
          * location ("start" or "anywhere"). If the term starts or ends with non word characters, then the match will not
          * require word boundaries on that side.
-         *
          * @param {string} term A term to convert to a RegExp
          * @returns {RegExp} The term converted to a RegExp
          */

package/lib/rules/no-whitespace-before-property.js

@@ -38,9 +38,9 @@ module.exports = {
 
         /**
          * Reports whitespace before property token
-         * @param {ASTNode} node - the node to report in the event of an error
-         * @param {Token} leftToken - the left token
-         * @param {Token} rightToken - the right token
+         * @param {ASTNode} node the node to report in the event of an error
+         * @param {Token} leftToken the left token
+         * @param {Token} rightToken the right token
          * @returns {void}
          * @private
          */

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

@@ -44,8 +44,7 @@ const OPTION_VALUE = {
 
 /**
  * Normalizes a given option value.
- *
- * @param {string|Object|undefined} value - An option value to parse.
+ * @param {string|Object|undefined} value An option value to parse.
  * @returns {{multiline: boolean, minProperties: number, consistent: boolean}} Normalized option object.
  */
 function normalizeOptionValue(value) {
@@ -72,8 +71,7 @@ function normalizeOptionValue(value) {
 
 /**
  * Normalizes a given option value.
- *
- * @param {string|Object|undefined} options - An option value to parse.
+ * @param {string|Object|undefined} options An option value to parse.
  * @returns {{
  *   ObjectExpression: {multiline: boolean, minProperties: number, consistent: boolean},
  *   ObjectPattern: {multiline: boolean, minProperties: number, consistent: boolean},
@@ -101,11 +99,10 @@ function normalizeOptions(options) {
 /**
  * Determines if ObjectExpression, ObjectPattern, ImportDeclaration or ExportNamedDeclaration
  * node needs to be checked for missing line breaks
- *
- * @param {ASTNode} node - Node under inspection
- * @param {Object} options - option specific to node type
- * @param {Token} first - First object property
- * @param {Token} last - Last object property
+ * @param {ASTNode} node Node under inspection
+ * @param {Object} options option specific to node type
+ * @param {Token} first First object property
+ * @param {Token} last Last object property
  * @returns {boolean} `true` if node needs to be checked for missing line breaks
  */
 function areLineBreaksRequired(node, options, first, last) {
@@ -171,7 +168,7 @@ module.exports = {
 
         /**
          * Reports a given node if it violated this rule.
-         * @param {ASTNode} node - A node to check. This is an ObjectExpression, ObjectPattern, ImportDeclaration or ExportNamedDeclaration node.
+         * @param {ASTNode} node A node to check. This is an ObjectExpression, ObjectPattern, ImportDeclaration or ExportNamedDeclaration node.
          * @returns {void}
          */
         function check(node) {

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

@@ -50,7 +50,7 @@ module.exports = {
          * Determines whether an option is set, relative to the spacing option.
          * If spaced is "always", then check whether option is set to false.
          * If spaced is "never", then check whether option is set to true.
-         * @param {Object} option - The option to exclude.
+         * @param {Object} option The option to exclude.
          * @returns {boolean} Whether or not the property is excluded.
          */
         function isOptionSet(option) {
@@ -69,21 +69,21 @@ module.exports = {
 
         /**
          * Reports that there shouldn't be a space after the first token
-         * @param {ASTNode} node - The node to report in the event of an error.
-         * @param {Token} token - The token to use for the report.
+         * @param {ASTNode} node The node to report in the event of an error.
+         * @param {Token} token The token to use for the report.
          * @returns {void}
          */
         function reportNoBeginningSpace(node, token) {
+            const nextToken = context.getSourceCode().getTokenAfter(token, { includeComments: true });
+
             context.report({
                 node,
-                loc: token.loc.start,
+                loc: { start: token.loc.end, end: nextToken.loc.start },
                 message: "There should be no space after '{{token}}'.",
                 data: {
                     token: token.value
                 },
                 fix(fixer) {
-                    const nextToken = context.getSourceCode().getTokenAfter(token, { includeComments: true });
-
                     return fixer.removeRange([token.range[1], nextToken.range[0]]);
                 }
             });
@@ -91,21 +91,21 @@ module.exports = {
 
         /**
          * Reports that there shouldn't be a space before the last token
-         * @param {ASTNode} node - The node to report in the event of an error.
-         * @param {Token} token - The token to use for the report.
+         * @param {ASTNode} node The node to report in the event of an error.
+         * @param {Token} token The token to use for the report.
          * @returns {void}
          */
         function reportNoEndingSpace(node, token) {
+            const previousToken = context.getSourceCode().getTokenBefore(token, { includeComments: true });
+
             context.report({
                 node,
-                loc: token.loc.start,
+                loc: { start: previousToken.loc.end, end: token.loc.start },
                 message: "There should be no space before '{{token}}'.",
                 data: {
                     token: token.value
                 },
                 fix(fixer) {
-                    const previousToken = context.getSourceCode().getTokenBefore(token, { includeComments: true });
-
                     return fixer.removeRange([previousToken.range[1], token.range[0]]);
                 }
             });
@@ -113,14 +113,14 @@ module.exports = {
 
         /**
          * Reports that there should be a space after the first token
-         * @param {ASTNode} node - The node to report in the event of an error.
-         * @param {Token} token - The token to use for the report.
+         * @param {ASTNode} node The node to report in the event of an error.
+         * @param {Token} token The token to use for the report.
          * @returns {void}
          */
         function reportRequiredBeginningSpace(node, token) {
             context.report({
                 node,
-                loc: token.loc.start,
+                loc: token.loc,
                 message: "A space is required after '{{token}}'.",
                 data: {
                     token: token.value
@@ -133,14 +133,14 @@ module.exports = {
 
         /**
          * Reports that there should be a space before the last token
-         * @param {ASTNode} node - The node to report in the event of an error.
-         * @param {Token} token - The token to use for the report.
+         * @param {ASTNode} node The node to report in the event of an error.
+         * @param {Token} token The token to use for the report.
          * @returns {void}
          */
         function reportRequiredEndingSpace(node, token) {
             context.report({
                 node,
-                loc: token.loc.start,
+                loc: token.loc,
                 message: "A space is required before '{{token}}'.",
                 data: {
                     token: token.value
@@ -201,8 +201,7 @@ module.exports = {
          * Because the last token of object patterns might be a type annotation,
          * this traverses tokens preceded by the last property, then returns the
          * first '}' token.
-         *
-         * @param {ASTNode} node - The node to get. This node is an
+         * @param {ASTNode} node The node to get. This node is an
          *      ObjectExpression or an ObjectPattern. And this node has one or
          *      more properties.
          * @returns {Token} '}' token.
@@ -215,7 +214,7 @@ module.exports = {
 
         /**
          * Reports a given object node if spacing in curly braces is invalid.
-         * @param {ASTNode} node - An ObjectExpression or ObjectPattern node to check.
+         * @param {ASTNode} node An ObjectExpression or ObjectPattern node to check.
          * @returns {void}
          */
         function checkForObject(node) {
@@ -233,7 +232,7 @@ module.exports = {
 
         /**
          * Reports a given import node if spacing in curly braces is invalid.
-         * @param {ASTNode} node - An ImportDeclaration node to check.
+         * @param {ASTNode} node An ImportDeclaration node to check.
          * @returns {void}
          */
         function checkForImport(node) {
@@ -261,7 +260,7 @@ module.exports = {
 
         /**
          * Reports a given export node if spacing in curly braces is invalid.
-         * @param {ASTNode} node - An ExportNamedDeclaration node to check.
+         * @param {ASTNode} node An ExportNamedDeclaration node to check.
          * @returns {void}
          */
         function checkForExport(node) {

package/lib/rules/object-shorthand.js

@@ -147,7 +147,7 @@ module.exports = {
 
         /**
          * Checks whether a node is a string literal.
-         * @param   {ASTNode} node - Any AST node.
+         * @param   {ASTNode} node Any AST node.
          * @returns {boolean} `true` if it is a string literal.
          */
         function isStringLiteral(node) {

package/lib/rules/one-var-declaration-per-line.js

@@ -41,7 +41,7 @@ module.exports = {
         /**
          * Determine if provided keyword is a variant of for specifiers
          * @private
-         * @param {string} keyword - keyword to test
+         * @param {string} keyword keyword to test
          * @returns {boolean} True if `keyword` is a variant of for specifier
          */
         function isForTypeSpecifier(keyword) {
@@ -51,7 +51,7 @@ module.exports = {
         /**
          * Checks newlines around variable declarations.
          * @private
-         * @param {ASTNode} node - `VariableDeclaration` node to test
+         * @param {ASTNode} node `VariableDeclaration` node to test
          * @returns {void}
          */
         function checkForNewLine(node) {