eslint 6.3.0 → 6.6.0

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

@@ -16,19 +16,26 @@ const astUtils = require("./utils/ast-utils");
 //------------------------------------------------------------------------------
 
 /**
- * Checks whether the given operator is a relational operator or not.
- *
- * @param {string} op - The operator type to check.
- * @returns {boolean} `true` if the operator is a relational operator.
+ * Checks whether the given operator is `in` or `instanceof`
+ * @param {string} op The operator type to check.
+ * @returns {boolean} `true` if the operator is `in` or `instanceof`
  */
-function isRelationalOperator(op) {
+function isInOrInstanceOfOperator(op) {
     return op === "in" || op === "instanceof";
 }
 
+/**
+ * Checks whether the given operator is an ordering relational operator or not.
+ * @param {string} op The operator type to check.
+ * @returns {boolean} `true` if the operator is an ordering relational operator.
+ */
+function isOrderingRelationalOperator(op) {
+    return op === "<" || op === ">" || op === ">=" || op === "<=";
+}
+
 /**
  * Checks whether the given node is a logical negation expression or not.
- *
- * @param {ASTNode} node - The node to check.
+ * @param {ASTNode} node The node to check.
  * @returns {boolean} `true` if the node is a logical negation expression.
  */
 function isNegation(node) {
@@ -50,8 +57,19 @@ module.exports = {
             url: "https://eslint.org/docs/rules/no-unsafe-negation"
         },
 
-        schema: [],
-        fixable: "code",
+        schema: [
+            {
+                type: "object",
+                properties: {
+                    enforceForOrderingRelations: {
+                        type: "boolean",
+                        default: false
+                    }
+                },
+                additionalProperties: false
+            }
+        ],
+        fixable: null,
         messages: {
             unexpected: "Unexpected negating the left operand of '{{operator}}' operator."
         }
@@ -59,10 +77,15 @@ module.exports = {
 
     create(context) {
         const sourceCode = context.getSourceCode();
+        const options = context.options[0] || {};
+        const enforceForOrderingRelations = options.enforceForOrderingRelations === true;
 
         return {
             BinaryExpression(node) {
-                if (isRelationalOperator(node.operator) &&
+                const orderingRelationRuleApplies = enforceForOrderingRelations && isOrderingRelationalOperator(node.operator);
+
+                if (
+                    (isInOrInstanceOfOperator(node.operator) || orderingRelationRuleApplies) &&
                     isNegation(node.left) &&
                     !astUtils.isParenthesised(sourceCode, node.left)
                 ) {
@@ -70,15 +93,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/no-unused-expressions.js

@@ -47,8 +47,9 @@ module.exports = {
             allowTernary = config.allowTernary || false,
             allowTaggedTemplates = config.allowTaggedTemplates || false;
 
+        // eslint-disable-next-line jsdoc/require-description
         /**
-         * @param {ASTNode} node - any node
+         * @param {ASTNode} node any node
          * @returns {boolean} whether the given node structurally represents a directive
          */
         function looksLikeDirective(node) {
@@ -56,9 +57,10 @@ module.exports = {
                 node.expression.type === "Literal" && typeof node.expression.value === "string";
         }
 
+        // eslint-disable-next-line jsdoc/require-description
         /**
-         * @param {Function} predicate - ([a] -> Boolean) the function used to make the determination
-         * @param {a[]} list - the input list
+         * @param {Function} predicate ([a] -> Boolean) the function used to make the determination
+         * @param {a[]} list the input list
          * @returns {a[]} the leading sequence of members in the given list that pass the given predicate
          */
         function takeWhile(predicate, list) {
@@ -70,17 +72,19 @@ module.exports = {
             return list.slice();
         }
 
+        // eslint-disable-next-line jsdoc/require-description
         /**
-         * @param {ASTNode} node - a Program or BlockStatement node
+         * @param {ASTNode} node a Program or BlockStatement node
          * @returns {ASTNode[]} the leading sequence of directive nodes in the given node's body
          */
         function directives(node) {
             return takeWhile(looksLikeDirective, node.body);
         }
 
+        // eslint-disable-next-line jsdoc/require-description
         /**
-         * @param {ASTNode} node - any node
-         * @param {ASTNode[]} ancestors - the given node's ancestors
+         * @param {ASTNode} node any node
+         * @param {ASTNode[]} ancestors the given node's ancestors
          * @returns {boolean} whether the given node is considered a directive in its current position
          */
         function isDirective(node, ancestors) {
@@ -94,7 +98,7 @@ module.exports = {
 
         /**
          * Determines whether or not a given node is a valid expression. Recurses on short circuit eval and ternary nodes if enabled by flags.
-         * @param {ASTNode} node - any node
+         * @param {ASTNode} node any node
          * @returns {boolean} whether the given node is a valid expression
          */
         function isValidExpression(node) {

package/lib/rules/no-unused-labels.js

@@ -35,8 +35,7 @@ module.exports = {
 
         /**
          * Adds a scope info to the stack.
-         *
-         * @param {ASTNode} node - A node to add. This is a LabeledStatement.
+         * @param {ASTNode} node A node to add. This is a LabeledStatement.
          * @returns {void}
          */
         function enterLabeledScope(node) {
@@ -50,8 +49,7 @@ module.exports = {
         /**
          * Removes the top of the stack.
          * At the same time, this reports the label if it's never used.
-         *
-         * @param {ASTNode} node - A node to report. This is a LabeledStatement.
+         * @param {ASTNode} node A node to report. This is a LabeledStatement.
          * @returns {void}
          */
         function exitLabeledScope(node) {
@@ -81,8 +79,7 @@ module.exports = {
 
         /**
          * Marks the label of a given node as used.
-         *
-         * @param {ASTNode} node - A node to mark. This is a BreakStatement or
+         * @param {ASTNode} node A node to mark. This is a BreakStatement or
          *      ContinueStatement.
          * @returns {void}
          */

package/lib/rules/no-unused-vars.js

@@ -103,7 +103,7 @@ module.exports = {
         /**
          * Generate the warning message about the variable being
          * defined and unused, including the ignore pattern if configured.
-         * @param {Variable} unusedVar - eslint-scope variable object.
+         * @param {Variable} unusedVar eslint-scope variable object.
          * @returns {string} The warning message to be used with this unused variable.
          */
         function getDefinedMessage(unusedVar) {
@@ -146,7 +146,7 @@ module.exports = {
 
         /**
          * Determines if a given variable is being exported from a module.
-         * @param {Variable} variable - eslint-scope variable object.
+         * @param {Variable} variable eslint-scope variable object.
          * @returns {boolean} True if the variable is exported, false if not.
          * @private
          */
@@ -172,7 +172,7 @@ module.exports = {
 
         /**
          * Determines if a variable has a sibling rest property
-         * @param {Variable} variable - eslint-scope variable object.
+         * @param {Variable} variable eslint-scope variable object.
          * @returns {boolean} True if the variable is exported, false if not.
          * @private
          */
@@ -195,7 +195,7 @@ module.exports = {
 
         /**
          * Determines if a reference is a read operation.
-         * @param {Reference} ref - An eslint-scope Reference
+         * @param {Reference} ref An eslint-scope Reference
          * @returns {boolean} whether the given reference represents a read operation
          * @private
          */
@@ -205,8 +205,8 @@ module.exports = {
 
         /**
          * Determine if an identifier is referencing an enclosing function name.
-         * @param {Reference} ref - The reference to check.
-         * @param {ASTNode[]} nodes - The candidate function nodes.
+         * @param {Reference} ref The reference to check.
+         * @param {ASTNode[]} nodes The candidate function nodes.
          * @returns {boolean} True if it's a self-reference, false if not.
          * @private
          */
@@ -226,7 +226,7 @@ module.exports = {
 
         /**
          * Gets a list of function definitions for a specified variable.
-         * @param {Variable} variable - eslint-scope variable object.
+         * @param {Variable} variable eslint-scope variable object.
          * @returns {ASTNode[]} Function nodes.
          * @private
          */
@@ -252,9 +252,8 @@ module.exports = {
 
         /**
          * Checks the position of given nodes.
-         *
-         * @param {ASTNode} inner - A node which is expected as inside.
-         * @param {ASTNode} outer - A node which is expected as outside.
+         * @param {ASTNode} inner A node which is expected as inside.
+         * @param {ASTNode} outer A node which is expected as outside.
          * @returns {boolean} `true` if the `inner` node exists in the `outer` node.
          * @private
          */
@@ -275,9 +274,8 @@ module.exports = {
          * - The reference is inside of a loop.
          * - The reference is inside of a function scope which is different from
          *   the declaration.
-         *
-         * @param {eslint-scope.Reference} ref - A reference to check.
-         * @param {ASTNode} prevRhsNode - The previous RHS node.
+         * @param {eslint-scope.Reference} ref A reference to check.
+         * @param {ASTNode} prevRhsNode The previous RHS node.
          * @returns {ASTNode|null} The RHS node or null.
          * @private
          */
@@ -310,9 +308,8 @@ module.exports = {
         /**
          * Checks whether a given function node is stored to somewhere or not.
          * If the function node is stored, the function can be used later.
-         *
-         * @param {ASTNode} funcNode - A function node to check.
-         * @param {ASTNode} rhsNode - The RHS node of the previous assignment.
+         * @param {ASTNode} funcNode A function node to check.
+         * @param {ASTNode} rhsNode The RHS node of the previous assignment.
          * @returns {boolean} `true` if under the following conditions:
          *      - the funcNode is assigned to a variable.
          *      - the funcNode is bound as an argument of a function call.
@@ -367,9 +364,8 @@ module.exports = {
          * - the function is bound as an argument of a function call.
          *
          * If a reference exists in a function which can be used later, the reference is read when the function is called.
-         *
-         * @param {ASTNode} id - An Identifier node to check.
-         * @param {ASTNode} rhsNode - The RHS node of the previous assignment.
+         * @param {ASTNode} id An Identifier node to check.
+         * @param {ASTNode} rhsNode The RHS node of the previous assignment.
          * @returns {boolean} `true` if the `id` node exists inside of a function node which can be used later.
          * @private
          */
@@ -385,9 +381,8 @@ module.exports = {
 
         /**
          * Checks whether a given reference is a read to update itself or not.
-         *
-         * @param {eslint-scope.Reference} ref - A reference to check.
-         * @param {ASTNode} rhsNode - The RHS node of the previous assignment.
+         * @param {eslint-scope.Reference} ref A reference to check.
+         * @param {ASTNode} rhsNode The RHS node of the previous assignment.
          * @returns {boolean} The reference is a read to update itself.
          * @private
          */
@@ -416,8 +411,7 @@ module.exports = {
 
         /**
          * Determine if an identifier is used either in for-in loops.
-         *
-         * @param {Reference} ref - The reference to check.
+         * @param {Reference} ref The reference to check.
          * @returns {boolean} whether reference is used in the for-in loops
          * @private
          */
@@ -453,7 +447,7 @@ module.exports = {
 
         /**
          * Determines if the variable is used.
-         * @param {Variable} variable - The variable to check.
+         * @param {Variable} variable The variable to check.
          * @returns {boolean} True if the variable is used
          * @private
          */
@@ -481,8 +475,7 @@ module.exports = {
 
         /**
          * Checks whether the given variable is after the last used parameter.
-         *
-         * @param {eslint-scope.Variable} variable - The variable to check.
+         * @param {eslint-scope.Variable} variable The variable to check.
          * @returns {boolean} `true` if the variable is defined after the last
          * used parameter.
          */
@@ -497,8 +490,8 @@ module.exports = {
 
         /**
          * Gets an array of variables without read references.
-         * @param {Scope} scope - an eslint-scope Scope object.
-         * @param {Variable[]} unusedVars - an array that saving result.
+         * @param {Scope} scope an eslint-scope Scope object.
+         * @param {Variable[]} unusedVars an array that saving result.
          * @returns {Variable[]} unused variables of the scope and descendant scopes.
          * @private
          */

package/lib/rules/no-use-before-define.js

@@ -14,8 +14,7 @@ const FOR_IN_OF_TYPE = /^For(?:In|Of)Statement$/u;
 
 /**
  * Parses a given value as options.
- *
- * @param {any} options - A value to parse.
+ * @param {any} options A value to parse.
  * @returns {Object} The parsed options.
  */
 function parseOptions(options) {
@@ -36,8 +35,7 @@ function parseOptions(options) {
 
 /**
  * Checks whether or not a given variable is a function declaration.
- *
- * @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 a function declaration.
  */
 function isFunction(variable) {
@@ -46,9 +44,8 @@ function isFunction(variable) {
 
 /**
  * Checks whether or not a given variable is a class declaration in an upper function scope.
- *
- * @param {eslint-scope.Variable} variable - A variable to check.
- * @param {eslint-scope.Reference} reference - A reference to check.
+ * @param {eslint-scope.Variable} variable A variable to check.
+ * @param {eslint-scope.Reference} reference A reference to check.
  * @returns {boolean} `true` if the variable is a class declaration.
  */
 function isOuterClass(variable, reference) {
@@ -60,8 +57,8 @@ function isOuterClass(variable, reference) {
 
 /**
  * Checks whether or not a given variable is a variable declaration in an upper function scope.
- * @param {eslint-scope.Variable} variable - A variable to check.
- * @param {eslint-scope.Reference} reference - A reference to check.
+ * @param {eslint-scope.Variable} variable A variable to check.
+ * @param {eslint-scope.Reference} reference A reference to check.
  * @returns {boolean} `true` if the variable is a variable declaration.
  */
 function isOuterVariable(variable, reference) {
@@ -73,9 +70,8 @@ function isOuterVariable(variable, reference) {
 
 /**
  * Checks whether or not a given location is inside of the range of a given node.
- *
- * @param {ASTNode} node - An node to check.
- * @param {number} location - A location to check.
+ * @param {ASTNode} node An node to check.
+ * @param {number} location A location to check.
  * @returns {boolean} `true` if the location is inside of the range of the node.
  */
 function isInRange(node, location) {
@@ -92,9 +88,8 @@ function isInRange(node, location) {
  *     var {a = a} = obj
  *     for (var a in a) {}
  *     for (var a of a) {}
- *
- * @param {Variable} variable - A variable to check.
- * @param {Reference} reference - A reference to check.
+ * @param {Variable} variable A variable to check.
+ * @param {Reference} reference A reference to check.
  * @returns {boolean} `true` if the reference is inside of the initializers.
  */
 function isInInitializer(variable, reference) {

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

@@ -13,7 +13,7 @@ const astUtils = require("./utils/ast-utils");
 
 /**
  * Checks whether or not a node is a `.call()`/`.apply()`.
- * @param {ASTNode} node - A CallExpression node to check.
+ * @param {ASTNode} node A CallExpression node to check.
  * @returns {boolean} Whether or not the node is a `.call()`/`.apply()`.
  */
 function isCallOrNonVariadicApply(node) {
@@ -31,9 +31,9 @@ function isCallOrNonVariadicApply(node) {
 
 /**
  * Checks whether or not `thisArg` is not changed by `.call()`/`.apply()`.
- * @param {ASTNode|null} expectedThis - The node that is the owner of the applied function.
- * @param {ASTNode} thisArg - The node that is given to the first argument of the `.call()`/`.apply()`.
- * @param {SourceCode} sourceCode - The ESLint source code object.
+ * @param {ASTNode|null} expectedThis The node that is the owner of the applied function.
+ * @param {ASTNode} thisArg The node that is given to the first argument of the `.call()`/`.apply()`.
+ * @param {SourceCode} sourceCode The ESLint source code object.
  * @returns {boolean} Whether or not `thisArg` is not changed by `.call()`/`.apply()`.
  */
 function isValidThisArg(expectedThis, thisArg, sourceCode) {

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

@@ -16,7 +16,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) {
@@ -25,7 +25,7 @@ function isConcatenation(node) {
 
 /**
  * Checks if the given token is a `+` token or not.
- * @param {Token} token - The token to check.
+ * @param {Token} token The token to check.
  * @returns {boolean} `true` if the token is a `+` token.
  */
 function isConcatOperatorToken(token) {
@@ -34,7 +34,7 @@ function isConcatOperatorToken(token) {
 
 /**
  * Get's the right most node on the left side of a BinaryExpression with + operator.
- * @param {ASTNode} node - A BinaryExpression node to check.
+ * @param {ASTNode} node A BinaryExpression node to check.
  * @returns {ASTNode} node
  */
 function getLeft(node) {
@@ -48,7 +48,7 @@ function getLeft(node) {
 
 /**
  * Get's the left most node on the right side of a BinaryExpression with + operator.
- * @param {ASTNode} node - A BinaryExpression node to check.
+ * @param {ASTNode} node A BinaryExpression node to check.
  * @returns {ASTNode} node
  */
 function getRight(node) {

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

@@ -117,10 +117,9 @@ module.exports = {
 
         /**
          * 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 +155,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) {