eslint 6.5.0 → 6.7.1

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

@@ -2,10 +2,21 @@
  * @fileoverview Rule to flag assignment in a conditional statement's test expression
  * @author Stephen Murray <spmurrayzzz>
  */
+
 "use strict";
 
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
 const astUtils = require("./utils/ast-utils");
 
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+const TEST_CONDITION_PARENT_TYPES = new Set(["IfStatement", "WhileStatement", "DoWhileStatement", "ForStatement", "ConditionalExpression"]);
+
 const NODE_DESCRIPTIONS = {
     DoWhileStatement: "a 'do...while' statement",
     ForStatement: "a 'for' statement",
@@ -55,7 +66,7 @@ module.exports = {
          */
         function isConditionalTestExpression(node) {
             return node.parent &&
-                node.parent.test &&
+                TEST_CONDITION_PARENT_TYPES.has(node.parent.type) &&
                 node === node.parent.test;
         }
 
@@ -105,8 +116,7 @@ module.exports = {
             ) {
 
                 context.report({
-                    node,
-                    loc: node.test.loc.start,
+                    node: node.test,
                     messageId: "missing"
                 });
             }
@@ -122,7 +132,7 @@ module.exports = {
 
             if (ancestor) {
                 context.report({
-                    node: ancestor,
+                    node,
                     messageId: "unexpected",
                     data: {
                         type: NODE_DESCRIPTIONS[ancestor.type] || ancestor.type

package/lib/rules/no-confusing-arrow.js

@@ -14,7 +14,7 @@ const astUtils = require("./utils/ast-utils.js");
 
 /**
  * Checks whether or not a node is a conditional expression.
- * @param {ASTNode} node - node to test
+ * @param {ASTNode} node node to test
  * @returns {boolean} `true` if the node is a conditional expression.
  */
 function isConditional(node) {
@@ -59,7 +59,7 @@ module.exports = {
 
         /**
          * Reports if an arrow function contains an ambiguous conditional.
-         * @param {ASTNode} node - A node to check and report.
+         * @param {ASTNode} node A node to check and report.
          * @returns {void}
          */
         function checkArrowFunc(node) {

package/lib/rules/no-console.js

@@ -54,8 +54,7 @@ module.exports = {
 
         /**
          * Checks whether the given reference is 'console' or not.
-         *
-         * @param {eslint-scope.Reference} reference - The reference to check.
+         * @param {eslint-scope.Reference} reference The reference to check.
          * @returns {boolean} `true` if the reference is 'console'.
          */
         function isConsole(reference) {
@@ -67,8 +66,7 @@ module.exports = {
         /**
          * Checks whether the property name of the given MemberExpression node
          * is allowed by options or not.
-         *
-         * @param {ASTNode} node - The MemberExpression node to check.
+         * @param {ASTNode} node The MemberExpression node to check.
          * @returns {boolean} `true` if the property name of the node is allowed.
          */
         function isAllowed(node) {
@@ -80,8 +78,7 @@ module.exports = {
         /**
          * Checks whether the given reference is a member access which is not
          * allowed by options or not.
-         *
-         * @param {eslint-scope.Reference} reference - The reference to check.
+         * @param {eslint-scope.Reference} reference The reference to check.
          * @returns {boolean} `true` if the reference is a member access which
          *      is not allowed by options.
          */
@@ -98,8 +95,7 @@ module.exports = {
 
         /**
          * Reports the given reference as a violation.
-         *
-         * @param {eslint-scope.Reference} reference - The reference to report.
+         * @param {eslint-scope.Reference} reference The reference to report.
          * @returns {void}
          */
         function report(reference) {

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

@@ -33,7 +33,7 @@ module.exports = {
 
         /**
          * Finds and reports references that are non initializer and writable.
-         * @param {Variable} variable - A variable to check.
+         * @param {Variable} variable A variable to check.
          * @returns {void}
          */
         function checkVariable(variable) {

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

@@ -0,0 +1,62 @@
+/**
+ * @fileoverview Rule to disallow returning value from constructor.
+ * @author Pig Fang <https://github.com/g-plane>
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = {
+    meta: {
+        type: "problem",
+
+        docs: {
+            description: "disallow returning value from constructor",
+            category: "Best Practices",
+            recommended: false,
+            url: "https://eslint.org/docs/rules/no-constructor-return"
+        },
+
+        schema: {},
+
+        fixable: null,
+
+        messages: {
+            unexpected: "Unexpected return statement in constructor."
+        }
+    },
+
+    create(context) {
+        const stack = [];
+
+        return {
+            onCodePathStart(_, node) {
+                stack.push(node);
+            },
+            onCodePathEnd() {
+                stack.pop();
+            },
+            ReturnStatement(node) {
+                const last = stack[stack.length - 1];
+
+                if (!last.parent) {
+                    return;
+                }
+
+                if (
+                    last.parent.type === "MethodDefinition" &&
+                    last.parent.kind === "constructor" &&
+                    (node.parent.parent === last || node.argument)
+                ) {
+                    context.report({
+                        node,
+                        messageId: "unexpected"
+                    });
+                }
+            }
+        };
+    }
+};

package/lib/rules/no-dupe-args.js

@@ -35,7 +35,7 @@ module.exports = {
 
         /**
          * Checks whether or not a given definition is a parameter's.
-         * @param {eslint-scope.DefEntry} def - A definition to check.
+         * @param {eslint-scope.DefEntry} def A definition to check.
          * @returns {boolean} `true` if the definition is a parameter's.
          */
         function isParameter(def) {

package/lib/rules/no-dupe-class-members.js

@@ -32,8 +32,8 @@ module.exports = {
 
         /**
          * Gets state of a given member name.
-         * @param {string} name - A name of a member.
-         * @param {boolean} isStatic - A flag which specifies that is a static member.
+         * @param {string} name A name of a member.
+         * @param {boolean} isStatic A flag which specifies that is a static member.
          * @returns {Object} A state of a given member name.
          *   - retv.init {boolean} A flag which shows the name is declared as normal member.
          *   - retv.get {boolean} A flag which shows the name is declared as getter.
@@ -55,8 +55,7 @@ module.exports = {
 
         /**
          * Gets the name text of a given node.
-         *
-         * @param {ASTNode} node - A node to get the name.
+         * @param {ASTNode} node A node to get the name.
          * @returns {string} The name text of the node.
          */
         function getName(node) {

package/lib/rules/no-dupe-else-if.js

@@ -0,0 +1,122 @@
+/**
+ * @fileoverview Rule to disallow duplicate conditions in if-else-if chains
+ * @author Milos Djermanovic
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("./utils/ast-utils");
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+/**
+ * Determines whether the first given array is a subset of the second given array.
+ * @param {Function} comparator A function to compare two elements, should return `true` if they are equal.
+ * @param {Array} arrA The array to compare from.
+ * @param {Array} arrB The array to compare against.
+ * @returns {boolean} `true` if the array `arrA` is a subset of the array `arrB`.
+ */
+function isSubsetByComparator(comparator, arrA, arrB) {
+    return arrA.every(a => arrB.some(b => comparator(a, b)));
+}
+
+/**
+ * Splits the given node by the given logical operator.
+ * @param {string} operator Logical operator `||` or `&&`.
+ * @param {ASTNode} node The node to split.
+ * @returns {ASTNode[]} Array of conditions that makes the node when joined by the operator.
+ */
+function splitByLogicalOperator(operator, node) {
+    if (node.type === "LogicalExpression" && node.operator === operator) {
+        return [...splitByLogicalOperator(operator, node.left), ...splitByLogicalOperator(operator, node.right)];
+    }
+    return [node];
+}
+
+const splitByOr = splitByLogicalOperator.bind(null, "||");
+const splitByAnd = splitByLogicalOperator.bind(null, "&&");
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = {
+    meta: {
+        type: "problem",
+
+        docs: {
+            description: "disallow duplicate conditions in if-else-if chains",
+            category: "Possible Errors",
+            recommended: false,
+            url: "https://eslint.org/docs/rules/no-dupe-else-if"
+        },
+
+        schema: [],
+
+        messages: {
+            unexpected: "This branch can never execute. Its condition is a duplicate or covered by previous conditions in the if-else-if chain."
+        }
+    },
+
+    create(context) {
+        const sourceCode = context.getSourceCode();
+
+        /**
+         * Determines whether the two given nodes are considered to be equal. In particular, given that the nodes
+         * represent expressions in a boolean context, `||` and `&&` can be considered as commutative operators.
+         * @param {ASTNode} a First node.
+         * @param {ASTNode} b Second node.
+         * @returns {boolean} `true` if the nodes are considered to be equal.
+         */
+        function equal(a, b) {
+            if (a.type !== b.type) {
+                return false;
+            }
+
+            if (
+                a.type === "LogicalExpression" &&
+                (a.operator === "||" || a.operator === "&&") &&
+                a.operator === b.operator
+            ) {
+                return equal(a.left, b.left) && equal(a.right, b.right) ||
+                    equal(a.left, b.right) && equal(a.right, b.left);
+            }
+
+            return astUtils.equalTokens(a, b, sourceCode);
+        }
+
+        const isSubset = isSubsetByComparator.bind(null, equal);
+
+        return {
+            IfStatement(node) {
+                const test = node.test,
+                    conditionsToCheck = test.type === "LogicalExpression" && test.operator === "&&"
+                        ? [test, ...splitByAnd(test)]
+                        : [test];
+                let current = node,
+                    listToCheck = conditionsToCheck.map(c => splitByOr(c).map(splitByAnd));
+
+                while (current.parent && current.parent.type === "IfStatement" && current.parent.alternate === current) {
+                    current = current.parent;
+
+                    const currentOrOperands = splitByOr(current.test).map(splitByAnd);
+
+                    listToCheck = listToCheck.map(orOperands => orOperands.filter(
+                        orOperand => !currentOrOperands.some(currentOrOperand => isSubset(currentOrOperand, orOperand))
+                    ));
+
+                    if (listToCheck.some(orOperands => orOperands.length === 0)) {
+                        context.report({ node: test, messageId: "unexpected" });
+                        break;
+                    }
+                }
+            }
+        };
+    }
+};

package/lib/rules/no-dupe-keys.js

@@ -23,9 +23,10 @@ const SET_KIND = /^(?:init|set)$/u;
  */
 class ObjectInfo {
 
+    // eslint-disable-next-line jsdoc/require-description
     /**
-     * @param {ObjectInfo|null} upper - The information of the outer object.
-     * @param {ASTNode} node - The ObjectExpression node of this information.
+     * @param {ObjectInfo|null} upper The information of the outer object.
+     * @param {ASTNode} node The ObjectExpression node of this information.
      */
     constructor(upper, node) {
         this.upper = upper;
@@ -35,7 +36,7 @@ class ObjectInfo {
 
     /**
      * Gets the information of the given Property node.
-     * @param {ASTNode} node - The Property node to get.
+     * @param {ASTNode} node The Property node to get.
      * @returns {{get: boolean, set: boolean}} The information of the property.
      */
     getPropertyInfo(node) {
@@ -49,7 +50,7 @@ class ObjectInfo {
 
     /**
      * Checks whether the given property has been defined already or not.
-     * @param {ASTNode} node - The Property node to check.
+     * @param {ASTNode} node The Property node to check.
      * @returns {boolean} `true` if the property has been defined.
      */
     isPropertyDefined(node) {
@@ -63,7 +64,7 @@ class ObjectInfo {
 
     /**
      * Defines the given property.
-     * @param {ASTNode} node - The Property node to define.
+     * @param {ASTNode} node The Property node to define.
      * @returns {void}
      */
     defineProperty(node) {

package/lib/rules/no-duplicate-imports.js

@@ -10,8 +10,7 @@
 
 /**
  * Returns the name of the module imported or re-exported.
- *
- * @param {ASTNode} node - A node to get.
+ * @param {ASTNode} node A node to get.
  * @returns {string} the name of the module, or empty string if no name.
  */
 function getValue(node) {
@@ -24,12 +23,11 @@ function getValue(node) {
 
 /**
  * Checks if the name of the import or export exists in the given array, and reports if so.
- *
- * @param {RuleContext} context - The ESLint rule context object.
- * @param {ASTNode} node - A node to get.
- * @param {string} value - The name of the imported or exported module.
- * @param {string[]} array - The array containing other imports or exports in the file.
- * @param {string} messageId - A messageId to be reported after the name of the module
+ * @param {RuleContext} context The ESLint rule context object.
+ * @param {ASTNode} node A node to get.
+ * @param {string} value The name of the imported or exported module.
+ * @param {string[]} array The array containing other imports or exports in the file.
+ * @param {string} messageId A messageId to be reported after the name of the module
  *
  * @returns {void} No return value
  */
@@ -47,16 +45,15 @@ function checkAndReport(context, node, value, array, messageId) {
 
 /**
  * @callback nodeCallback
- * @param {ASTNode} node - A node to handle.
+ * @param {ASTNode} node A node to handle.
  */
 
 /**
  * Returns a function handling the imports of a given file
- *
- * @param {RuleContext} context - The ESLint rule context object.
- * @param {boolean} includeExports - Whether or not to check for exports in addition to imports.
- * @param {string[]} importsInFile - The array containing other imports in the file.
- * @param {string[]} exportsInFile - The array containing other exports in the file.
+ * @param {RuleContext} context The ESLint rule context object.
+ * @param {boolean} includeExports Whether or not to check for exports in addition to imports.
+ * @param {string[]} importsInFile The array containing other imports in the file.
+ * @param {string[]} exportsInFile The array containing other exports in the file.
  *
  * @returns {nodeCallback} A function passed to ESLint to handle the statement.
  */
@@ -78,10 +75,9 @@ function handleImports(context, includeExports, importsInFile, exportsInFile) {
 
 /**
  * Returns a function handling the exports of a given file
- *
- * @param {RuleContext} context - The ESLint rule context object.
- * @param {string[]} importsInFile - The array containing other imports in the file.
- * @param {string[]} exportsInFile - The array containing other exports in the file.
+ * @param {RuleContext} context The ESLint rule context object.
+ * @param {string[]} importsInFile The array containing other imports in the file.
+ * @param {string[]} exportsInFile The array containing other exports in the file.
  *
  * @returns {nodeCallback} A function passed to ESLint to handle the statement.
  */

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

@@ -58,7 +58,6 @@ module.exports = {
          *
          * This is not a generic function. In particular, it is assumed that the scope is a function scope or
          * a function's inner scope, and that the names can be valid identifiers in the given scope.
-         *
          * @param {string[]} names Array of variable names.
          * @param {eslint-scope.Scope} scope Function scope or a function's inner scope.
          * @returns {boolean} True if all names can be safely declared, false otherwise.
@@ -134,7 +133,6 @@ module.exports = {
 
         /**
          * Checks whether the removal of `else` and its braces is safe from variable name collisions.
-         *
          * @param {Node} node The 'else' node.
          * @param {eslint-scope.Scope} scope The scope in which the node and the whole 'if' statement is.
          * @returns {boolean} True if it is safe, false otherwise.
@@ -171,7 +169,6 @@ module.exports = {
 
         /**
          * Display the context report if rule is violated
-         *
          * @param {Node} node The 'else' node
          * @returns {void}
          */
@@ -255,7 +252,6 @@ module.exports = {
 
         /**
          * Check to see if the node is a ReturnStatement
-         *
          * @param {Node} node The node being evaluated
          * @returns {boolean} True if node is a return
          */
@@ -267,7 +263,6 @@ module.exports = {
          * Naive return checking, does not iterate through the whole
          * BlockStatement because we make the assumption that the ReturnStatement
          * will be the last node in the body of the BlockStatement.
-         *
          * @param {Node} node The consequent/alternate node
          * @returns {boolean} True if it has a return
          */
@@ -284,7 +279,6 @@ module.exports = {
         /**
          * Check to see if the node is valid for evaluation,
          * meaning it has an else.
-         *
          * @param {Node} node The node being evaluated
          * @returns {boolean} True if the node is valid
          */
@@ -296,7 +290,6 @@ module.exports = {
          * If the consequent is an IfStatement, check to see if it has an else
          * and both its consequent and alternate path return, meaning this is
          * a nested case of rule violation.  If-Else not considered currently.
-         *
          * @param {Node} node The consequent node
          * @returns {boolean} True if this is a nested rule violation
          */
@@ -309,7 +302,6 @@ module.exports = {
          * Check the consequent/body node to make sure it is not
          * a ReturnStatement or an IfStatement that returns on both
          * code paths.
-         *
          * @param {Node} node The consequent or body node
          * @returns {boolean} `true` if it is a Return/If node that always returns.
          */

package/lib/rules/no-empty-function.js

@@ -28,8 +28,7 @@ const ALLOW_OPTIONS = Object.freeze([
 
 /**
  * Gets the kind of a given function node.
- *
- * @param {ASTNode} node - A function node to get. This is one of
+ * @param {ASTNode} node A function node to get. This is one of
  *      an ArrowFunctionExpression, a FunctionDeclaration, or a
  *      FunctionExpression.
  * @returns {string} The kind of the function. This is one of "functions",
@@ -130,8 +129,7 @@ module.exports = {
          * - Not allowed by options.
          * - The body is empty.
          * - The body doesn't have any comments.
-         *
-         * @param {ASTNode} node - A function node to report. This is one of
+         * @param {ASTNode} node A function node to report. This is one of
          *      an ArrowFunctionExpression, a FunctionDeclaration, or a
          *      FunctionExpression.
          * @returns {void}

package/lib/rules/no-eval.js

@@ -22,9 +22,8 @@ const candidatesOfGlobalObject = Object.freeze([
 
 /**
  * Checks a given node is a Identifier node of the specified name.
- *
- * @param {ASTNode} node - A node to check.
- * @param {string} name - A name to check.
+ * @param {ASTNode} node A node to check.
+ * @param {string} name A name to check.
  * @returns {boolean} `true` if the node is a Identifier node of the name.
  */
 function isIdentifier(node, name) {
@@ -33,9 +32,8 @@ function isIdentifier(node, name) {
 
 /**
  * Checks a given node is a Literal node of the specified string value.
- *
- * @param {ASTNode} node - A node to check.
- * @param {string} name - A name to check.
+ * @param {ASTNode} node A node to check.
+ * @param {string} name A name to check.
  * @returns {boolean} `true` if the node is a Literal node of the name.
  */
 function isConstant(node, name) {
@@ -57,9 +55,8 @@ function isConstant(node, name) {
 /**
  * Checks a given node is a MemberExpression node which has the specified name's
  * property.
- *
- * @param {ASTNode} node - A node to check.
- * @param {string} name - A name to check.
+ * @param {ASTNode} node A node to check.
+ * @param {string} name A name to check.
  * @returns {boolean} `true` if the node is a MemberExpression node which has
  *      the specified name's property
  */
@@ -113,8 +110,7 @@ module.exports = {
          *
          * This is used in order to check whether or not `this` binding is a
          * reference to the global object.
-         *
-         * @param {ASTNode} node - A node of the scope. This is one of Program,
+         * @param {ASTNode} node A node of the scope. This is one of Program,
          *      FunctionDeclaration, FunctionExpression, and ArrowFunctionExpression.
          * @returns {void}
          */
@@ -132,7 +128,6 @@ module.exports = {
 
         /**
          * Pops a variable scope from the stack.
-         *
          * @returns {void}
          */
         function exitVarScope() {
@@ -148,8 +143,7 @@ module.exports = {
          * The location of the report is always `eval` `Identifier` (or possibly
          * `Literal`). The type of the report is `CallExpression` if the parent is
          * `CallExpression`. Otherwise, it's the given node type.
-         *
-         * @param {ASTNode} node - A node to report.
+         * @param {ASTNode} node A node to report.
          * @returns {void}
          */
         function report(node) {
@@ -171,8 +165,7 @@ module.exports = {
 
         /**
          * Reports accesses of `eval` via the global object.
-         *
-         * @param {eslint-scope.Scope} globalScope - The global scope.
+         * @param {eslint-scope.Scope} globalScope The global scope.
          * @returns {void}
          */
         function reportAccessingEvalViaGlobalObject(globalScope) {
@@ -205,8 +198,7 @@ module.exports = {
 
         /**
          * Reports all accesses of `eval` (excludes direct calls to eval).
-         *
-         * @param {eslint-scope.Scope} globalScope - The global scope.
+         * @param {eslint-scope.Scope} globalScope The global scope.
          * @returns {void}
          */
         function reportAccessingEval(globalScope) {

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

@@ -33,7 +33,7 @@ module.exports = {
 
         /**
          * Finds and reports references that are non initializer and writable.
-         * @param {Variable} variable - A variable to check.
+         * @param {Variable} variable A variable to check.
          * @returns {void}
          */
         function checkVariable(variable) {