eslint 6.5.0 → 6.7.1

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

@@ -0,0 +1,227 @@
+/**
+ * @fileoverview Rule to disallow returning values from setters
+ * @author Milos Djermanovic
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("./utils/ast-utils");
+const { findVariable } = require("eslint-utils");
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+/**
+ * Determines whether the given identifier node is a reference to a global variable.
+ * @param {ASTNode} node `Identifier` node to check.
+ * @param {Scope} scope Scope to which the node belongs.
+ * @returns {boolean} True if the identifier is a reference to a global variable.
+ */
+function isGlobalReference(node, scope) {
+    const variable = findVariable(scope, node);
+
+    return variable !== null && variable.scope.type === "global" && variable.defs.length === 0;
+}
+
+/**
+ * Determines whether the given node is an argument of the specified global method call, at the given `index` position.
+ * E.g., for given `index === 1`, this function checks for `objectName.methodName(foo, node)`, where objectName is a global variable.
+ * @param {ASTNode} node The node to check.
+ * @param {Scope} scope Scope to which the node belongs.
+ * @param {string} objectName Name of the global object.
+ * @param {string} methodName Name of the method.
+ * @param {number} index The given position.
+ * @returns {boolean} `true` if the node is argument at the given position.
+ */
+function isArgumentOfGlobalMethodCall(node, scope, objectName, methodName, index) {
+    const parent = node.parent;
+
+    return parent.type === "CallExpression" &&
+        parent.arguments[index] === node &&
+        parent.callee.type === "MemberExpression" &&
+        astUtils.getStaticPropertyName(parent.callee) === methodName &&
+        parent.callee.object.type === "Identifier" &&
+        parent.callee.object.name === objectName &&
+        isGlobalReference(parent.callee.object, scope);
+}
+
+/**
+ * Determines whether the given node is used as a property descriptor.
+ * @param {ASTNode} node The node to check.
+ * @param {Scope} scope Scope to which the node belongs.
+ * @returns {boolean} `true` if the node is a property descriptor.
+ */
+function isPropertyDescriptor(node, scope) {
+    if (
+        isArgumentOfGlobalMethodCall(node, scope, "Object", "defineProperty", 2) ||
+        isArgumentOfGlobalMethodCall(node, scope, "Reflect", "defineProperty", 2)
+    ) {
+        return true;
+    }
+
+    const parent = node.parent;
+
+    if (
+        parent.type === "Property" &&
+        parent.value === node
+    ) {
+        const grandparent = parent.parent;
+
+        if (
+            grandparent.type === "ObjectExpression" &&
+            (
+                isArgumentOfGlobalMethodCall(grandparent, scope, "Object", "create", 1) ||
+                isArgumentOfGlobalMethodCall(grandparent, scope, "Object", "defineProperties", 1)
+            )
+        ) {
+            return true;
+        }
+    }
+
+    return false;
+}
+
+/**
+ * Determines whether the given function node is used as a setter function.
+ * @param {ASTNode} node The node to check.
+ * @param {Scope} scope Scope to which the node belongs.
+ * @returns {boolean} `true` if the node is a setter.
+ */
+function isSetter(node, scope) {
+    const parent = node.parent;
+
+    if (
+        parent.kind === "set" &&
+        parent.value === node
+    ) {
+
+        // Setter in an object literal or in a class
+        return true;
+    }
+
+    if (
+        parent.type === "Property" &&
+        parent.value === node &&
+        astUtils.getStaticPropertyName(parent) === "set" &&
+        parent.parent.type === "ObjectExpression" &&
+        isPropertyDescriptor(parent.parent, scope)
+    ) {
+
+        // Setter in a property descriptor
+        return true;
+    }
+
+    return false;
+}
+
+/**
+ * Finds function's outer scope.
+ * @param {Scope} scope Function's own scope.
+ * @returns {Scope} Function's outer scope.
+ */
+function getOuterScope(scope) {
+    const upper = scope.upper;
+
+    if (upper.type === "function-expression-name") {
+        return upper.upper;
+    }
+
+    return upper;
+}
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = {
+    meta: {
+        type: "problem",
+
+        docs: {
+            description: "disallow returning values from setters",
+            category: "Possible Errors",
+            recommended: false,
+            url: "https://eslint.org/docs/rules/no-setter-return"
+        },
+
+        schema: [],
+
+        messages: {
+            returnsValue: "Setter cannot return a value."
+        }
+    },
+
+    create(context) {
+        let funcInfo = null;
+
+        /**
+         * Creates and pushes to the stack a function info object for the given function node.
+         * @param {ASTNode} node The function node.
+         * @returns {void}
+         */
+        function enterFunction(node) {
+            const outerScope = getOuterScope(context.getScope());
+
+            funcInfo = {
+                upper: funcInfo,
+                isSetter: isSetter(node, outerScope)
+            };
+        }
+
+        /**
+         * Pops the current function info object from the stack.
+         * @returns {void}
+         */
+        function exitFunction() {
+            funcInfo = funcInfo.upper;
+        }
+
+        /**
+         * Reports the given node.
+         * @param {ASTNode} node Node to report.
+         * @returns {void}
+         */
+        function report(node) {
+            context.report({ node, messageId: "returnsValue" });
+        }
+
+        return {
+
+            /*
+             * Function declarations cannot be setters, but we still have to track them in the `funcInfo` stack to avoid
+             * false positives, because a ReturnStatement node can belong to a function declaration inside a setter.
+             *
+             * Note: A previously declared function can be referenced and actually used as a setter in a property descriptor,
+             * but that's out of scope for this rule.
+             */
+            FunctionDeclaration: enterFunction,
+            FunctionExpression: enterFunction,
+            ArrowFunctionExpression(node) {
+                enterFunction(node);
+
+                if (funcInfo.isSetter && node.expression) {
+
+                    // { set: foo => bar } property descriptor. Report implicit return 'bar' as the equivalent for a return statement.
+                    report(node.body);
+                }
+            },
+
+            "FunctionDeclaration:exit": exitFunction,
+            "FunctionExpression:exit": exitFunction,
+            "ArrowFunctionExpression:exit": exitFunction,
+
+            ReturnStatement(node) {
+
+                // Global returns (e.g., at the top level of a Node module) don't have `funcInfo`.
+                if (funcInfo && funcInfo.isSetter && node.argument) {
+                    report(node);
+                }
+            }
+        };
+    }
+};

package/lib/rules/no-shadow.js

@@ -54,7 +54,6 @@ module.exports = {
 
         /**
          * Check if variable name is allowed.
-         *
          * @param  {ASTNode} variable The variable to check.
          * @returns {boolean} Whether or not the variable name is allowed.
          */
@@ -67,7 +66,6 @@ module.exports = {
          *
          * ClassDeclaration creates two variables of its name into its outer scope and its class scope.
          * So we should ignore the variable in the class scope.
-         *
          * @param {Object} variable The variable to check.
          * @returns {boolean} Whether or not the variable of the class name in the class scope of ClassDeclaration.
          */
@@ -82,7 +80,6 @@ module.exports = {
          *
          * To avoid reporting at declarations such as `var a = function a() {};`.
          * But it should report `var a = function(a) {};` or `var a = function() { function a() {} };`.
-         *
          * @param {Object} variable The variable to check.
          * @param {Object} scopeVar The scope variable to look for.
          * @returns {boolean} Whether or not the variable is inside initializer of scopeVar.
@@ -139,7 +136,7 @@ module.exports = {
 
         /**
          * Checks the current context for shadowed variables.
-         * @param {Scope} scope - Fixme
+         * @param {Scope} scope Fixme
          * @returns {void}
          */
         function checkForShadows(scope) {

package/lib/rules/no-tabs.js

@@ -55,8 +55,14 @@ module.exports = {
                         context.report({
                             node,
                             loc: {
-                                line: index + 1,
-                                column: match.index
+                                start: {
+                                    line: index + 1,
+                                    column: match.index
+                                },
+                                end: {
+                                    line: index + 1,
+                                    column: match.index + match[0].length
+                                }
                             },
                             message: "Unexpected tab character."
                         });

package/lib/rules/no-this-before-super.js

@@ -17,7 +17,7 @@ const astUtils = require("./utils/ast-utils");
 
 /**
  * Checks whether or not a given node is a constructor.
- * @param {ASTNode} node - A node to check. This node type is one of
+ * @param {ASTNode} node A node to check. This node type is one of
  *   `Program`, `FunctionDeclaration`, `FunctionExpression`, and
  *   `ArrowFunctionExpression`.
  * @returns {boolean} `true` if the node is a constructor.
@@ -71,7 +71,7 @@ module.exports = {
 
         /**
          * Gets whether or not `super()` is called in a given code path segment.
-         * @param {CodePathSegment} segment - A code path segment to get.
+         * @param {CodePathSegment} segment A code path segment to get.
          * @returns {boolean} `true` if `super()` is called.
          */
         function isCalled(segment) {
@@ -99,7 +99,7 @@ module.exports = {
 
         /**
          * Sets a given node as invalid.
-         * @param {ASTNode} node - A node to set as invalid. This is one of
+         * @param {ASTNode} node A node to set as invalid. This is one of
          *      a ThisExpression and a Super.
          * @returns {void}
          */
@@ -135,8 +135,8 @@ module.exports = {
 
             /**
              * Adds information of a constructor into the stack.
-             * @param {CodePath} codePath - A code path which was started.
-             * @param {ASTNode} node - The current node.
+             * @param {CodePath} codePath A code path which was started.
+             * @param {ASTNode} node The current node.
              * @returns {void}
              */
             onCodePathStart(codePath, node) {
@@ -169,8 +169,7 @@ module.exports = {
              *
              * And this treverses all segments of this code path then reports every
              * invalid node.
-             *
-             * @param {CodePath} codePath - A code path which was ended.
+             * @param {CodePath} codePath A code path which was ended.
              * @returns {void}
              */
             onCodePathEnd(codePath) {
@@ -204,7 +203,7 @@ module.exports = {
 
             /**
              * Initialize information of a given code path segment.
-             * @param {CodePathSegment} segment - A code path segment to initialize.
+             * @param {CodePathSegment} segment A code path segment to initialize.
              * @returns {void}
              */
             onCodePathSegmentStart(segment) {
@@ -225,9 +224,9 @@ module.exports = {
             /**
              * Update information of the code path segment when a code path was
              * looped.
-             * @param {CodePathSegment} fromSegment - The code path segment of the
+             * @param {CodePathSegment} fromSegment The code path segment of the
              *      end of a loop.
-             * @param {CodePathSegment} toSegment - A code path segment of the head
+             * @param {CodePathSegment} toSegment A code path segment of the head
              *      of a loop.
              * @returns {void}
              */
@@ -258,7 +257,7 @@ module.exports = {
 
             /**
              * Reports if this is before `super()`.
-             * @param {ASTNode} node - A target node.
+             * @param {ASTNode} node A target node.
              * @returns {void}
              */
             ThisExpression(node) {
@@ -269,7 +268,7 @@ module.exports = {
 
             /**
              * Reports if this is before `super()`.
-             * @param {ASTNode} node - A target node.
+             * @param {ASTNode} node A target node.
              * @returns {void}
              */
             Super(node) {
@@ -280,7 +279,7 @@ module.exports = {
 
             /**
              * Marks `super()` called.
-             * @param {ASTNode} node - A target node.
+             * @param {ASTNode} node A target node.
              * @returns {void}
              */
             "CallExpression:exit"(node) {

package/lib/rules/no-trailing-spaces.js

@@ -90,7 +90,11 @@ module.exports = {
             const lines = new Set();
 
             comments.forEach(comment => {
-                for (let i = comment.loc.start.line; i <= comment.loc.end.line; i++) {
+                const endLine = comment.type === "Block"
+                    ? comment.loc.end.line - 1
+                    : comment.loc.end.line;
+
+                for (let i = comment.loc.start.line; i <= endLine; i++) {
                     lines.add(i);
                 }
             });
@@ -122,7 +126,7 @@ module.exports = {
                     fixRange = [];
 
                 for (let i = 0, ii = lines.length; i < ii; i++) {
-                    const matches = re.exec(lines[i]);
+                    const lineNumber = i + 1;
 
                     /*
                      * Always add linebreak length to line length to accommodate for line break (\n or \r\n)
@@ -132,14 +136,22 @@ module.exports = {
                     const linebreakLength = linebreaks && linebreaks[i] ? linebreaks[i].length : 1;
                     const lineLength = lines[i].length + linebreakLength;
 
+                    const matches = re.exec(lines[i]);
+
                     if (matches) {
                         const location = {
-                            line: i + 1,
-                            column: matches.index
+                            start: {
+                                line: lineNumber,
+                                column: matches.index
+                            },
+                            end: {
+                                line: lineNumber,
+                                column: lineLength - linebreakLength
+                            }
                         };
 
-                        const rangeStart = totalLength + location.column;
-                        const rangeEnd = totalLength + lineLength - linebreakLength;
+                        const rangeStart = totalLength + location.start.column;
+                        const rangeEnd = totalLength + location.end.column;
                         const containingNode = sourceCode.getNodeByRangeIndex(rangeStart);
 
                         if (containingNode && containingNode.type === "TemplateElement" &&
@@ -160,7 +172,7 @@ module.exports = {
 
                         fixRange = [rangeStart, rangeEnd];
 
-                        if (!ignoreComments || !commentLineNumbers.has(location.line)) {
+                        if (!ignoreComments || !commentLineNumbers.has(lineNumber)) {
                             report(node, location, fixRange);
                         }
                     }

package/lib/rules/no-underscore-dangle.js

@@ -38,6 +38,10 @@ module.exports = {
                         type: "boolean",
                         default: false
                     },
+                    allowAfterThisConstructor: {
+                        type: "boolean",
+                        default: false
+                    },
                     enforceInMethodNames: {
                         type: "boolean",
                         default: false
@@ -54,6 +58,7 @@ module.exports = {
         const ALLOWED_VARIABLES = options.allow ? options.allow : [];
         const allowAfterThis = typeof options.allowAfterThis !== "undefined" ? options.allowAfterThis : false;
         const allowAfterSuper = typeof options.allowAfterSuper !== "undefined" ? options.allowAfterSuper : false;
+        const allowAfterThisConstructor = typeof options.allowAfterThisConstructor !== "undefined" ? options.allowAfterThisConstructor : false;
         const enforceInMethodNames = typeof options.enforceInMethodNames !== "undefined" ? options.enforceInMethodNames : false;
 
         //-------------------------------------------------------------------------
@@ -72,7 +77,7 @@ module.exports = {
 
         /**
          * Check if identifier has a underscore at the end
-         * @param {ASTNode} identifier node to evaluate
+         * @param {string} identifier name of the node
          * @returns {boolean} true if its is present
          * @private
          */
@@ -84,7 +89,7 @@ module.exports = {
 
         /**
          * Check if identifier is a special case member expression
-         * @param {ASTNode} identifier node to evaluate
+         * @param {string} identifier name of the node
          * @returns {boolean} true if its is a special case
          * @private
          */
@@ -94,7 +99,7 @@ module.exports = {
 
         /**
          * Check if identifier is a special case variable expression
-         * @param {ASTNode} identifier node to evaluate
+         * @param {string} identifier name of the node
          * @returns {boolean} true if its is a special case
          * @private
          */
@@ -104,6 +109,18 @@ module.exports = {
             return identifier === "_";
         }
 
+        /**
+         * Check if a node is a member reference of this.constructor
+         * @param {ASTNode} node node to evaluate
+         * @returns {boolean} true if it is a reference on this.constructor
+         * @private
+         */
+        function isThisConstructorReference(node) {
+            return node.object.type === "MemberExpression" &&
+                node.object.property.name === "constructor" &&
+                node.object.object.type === "ThisExpression";
+        }
+
         /**
          * Check if function has a underscore at the end
          * @param {ASTNode} node node to evaluate
@@ -156,11 +173,13 @@ module.exports = {
         function checkForTrailingUnderscoreInMemberExpression(node) {
             const identifier = node.property.name,
                 isMemberOfThis = node.object.type === "ThisExpression",
-                isMemberOfSuper = node.object.type === "Super";
+                isMemberOfSuper = node.object.type === "Super",
+                isMemberOfThisConstructor = isThisConstructorReference(node);
 
             if (typeof identifier !== "undefined" && hasTrailingUnderscore(identifier) &&
                 !(isMemberOfThis && allowAfterThis) &&
                 !(isMemberOfSuper && allowAfterSuper) &&
+                !(isMemberOfThisConstructor && allowAfterThisConstructor) &&
                 !isSpecialCaseIdentifierForMemberExpression(identifier) && !isAllowed(identifier)) {
                 context.report({
                     node,

package/lib/rules/no-unmodified-loop-condition.js

@@ -35,8 +35,7 @@ const DYNAMIC_PATTERN = /^(?:Call|Member|New|TaggedTemplate|Yield)Expression$/u;
 
 /**
  * Checks whether or not a given reference is a write reference.
- *
- * @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 a write reference.
  */
 function isWriteReference(reference) {
@@ -53,8 +52,7 @@ function isWriteReference(reference) {
 /**
  * Checks whether or not a given loop condition info does not have the modified
  * flag.
- *
- * @param {LoopConditionInfo} condition - A loop condition info to check.
+ * @param {LoopConditionInfo} condition A loop condition info to check.
  * @returns {boolean} `true` if the loop condition info is "unmodified".
  */
 function isUnmodified(condition) {
@@ -64,8 +62,7 @@ function isUnmodified(condition) {
 /**
  * Checks whether or not a given loop condition info does not have the modified
  * flag and does not have the group this condition belongs to.
- *
- * @param {LoopConditionInfo} condition - A loop condition info to check.
+ * @param {LoopConditionInfo} condition A loop condition info to check.
  * @returns {boolean} `true` if the loop condition info is "unmodified".
  */
 function isUnmodifiedAndNotBelongToGroup(condition) {
@@ -74,9 +71,8 @@ function isUnmodifiedAndNotBelongToGroup(condition) {
 
 /**
  * Checks whether or not a given reference is inside of a given node.
- *
- * @param {ASTNode} node - A node to check.
- * @param {eslint-scope.Reference} reference - A reference to check.
+ * @param {ASTNode} node A node to check.
+ * @param {eslint-scope.Reference} reference A reference to check.
  * @returns {boolean} `true` if the reference is inside of the node.
  */
 function isInRange(node, reference) {
@@ -88,9 +84,8 @@ function isInRange(node, reference) {
 
 /**
  * Checks whether or not a given reference is inside of a loop node's condition.
- *
- * @param {ASTNode} node - A node to check.
- * @param {eslint-scope.Reference} reference - A reference to check.
+ * @param {ASTNode} node A node to check.
+ * @param {eslint-scope.Reference} reference A reference to check.
  * @returns {boolean} `true` if the reference is inside of the loop node's
  *      condition.
  */
@@ -108,8 +103,7 @@ const isInLoop = {
 /**
  * Gets the function which encloses a given reference.
  * This supports only FunctionDeclaration.
- *
- * @param {eslint-scope.Reference} reference - A reference to get.
+ * @param {eslint-scope.Reference} reference A reference to get.
  * @returns {ASTNode|null} The function node or null.
  */
 function getEncloseFunctionDeclaration(reference) {
@@ -128,9 +122,8 @@ function getEncloseFunctionDeclaration(reference) {
 
 /**
  * Updates the "modified" flags of given loop conditions with given modifiers.
- *
- * @param {LoopConditionInfo[]} conditions - The loop conditions to be updated.
- * @param {eslint-scope.Reference[]} modifiers - The references to update.
+ * @param {LoopConditionInfo[]} conditions The loop conditions to be updated.
+ * @param {eslint-scope.Reference[]} modifiers The references to update.
  * @returns {void}
  */
 function updateModifiedFlag(conditions, modifiers) {
@@ -183,8 +176,7 @@ module.exports = {
 
         /**
          * Reports a given condition info.
-         *
-         * @param {LoopConditionInfo} condition - A loop condition info to report.
+         * @param {LoopConditionInfo} condition A loop condition info to report.
          * @returns {void}
          */
         function report(condition) {
@@ -199,8 +191,7 @@ module.exports = {
 
         /**
          * Registers given conditions to the group the condition belongs to.
-         *
-         * @param {LoopConditionInfo[]} conditions - A loop condition info to
+         * @param {LoopConditionInfo[]} conditions A loop condition info to
          *      register.
          * @returns {void}
          */
@@ -222,8 +213,7 @@ module.exports = {
 
         /**
          * Reports references which are inside of unmodified groups.
-         *
-         * @param {LoopConditionInfo[]} conditions - A loop condition info to report.
+         * @param {LoopConditionInfo[]} conditions A loop condition info to report.
          * @returns {void}
          */
         function checkConditionsInGroup(conditions) {
@@ -234,8 +224,7 @@ module.exports = {
 
         /**
          * Checks whether or not a given group node has any dynamic elements.
-         *
-         * @param {ASTNode} root - A node to check.
+         * @param {ASTNode} root A node to check.
          *      This node is one of BinaryExpression or ConditionalExpression.
          * @returns {boolean} `true` if the node is dynamic.
          */
@@ -259,8 +248,7 @@ module.exports = {
 
         /**
          * Creates the loop condition information from a given reference.
-         *
-         * @param {eslint-scope.Reference} reference - A reference to create.
+         * @param {eslint-scope.Reference} reference A reference to create.
          * @returns {LoopConditionInfo|null} Created loop condition info, or null.
          */
         function toLoopCondition(reference) {
@@ -313,8 +301,7 @@ module.exports = {
         /**
          * Finds unmodified references which are inside of a loop condition.
          * Then reports the references which are outside of groups.
-         *
-         * @param {eslint-scope.Variable} variable - A variable to report.
+         * @param {eslint-scope.Variable} variable A variable to report.
          * @returns {void}
          */
         function checkReferences(variable) {

package/lib/rules/no-unneeded-ternary.js

@@ -57,7 +57,7 @@ module.exports = {
 
         /**
          * Test if the node is a boolean literal
-         * @param {ASTNode} node - The node to report.
+         * @param {ASTNode} node The node to report.
          * @returns {boolean} True if the its a boolean literal
          * @private
          */
@@ -91,7 +91,7 @@ module.exports = {
 
         /**
          * Tests if a given node always evaluates to a boolean value
-         * @param {ASTNode} node - An expression node
+         * @param {ASTNode} node An expression node
          * @returns {boolean} True if it is determined that the node will always evaluate to a boolean value
          */
         function isBooleanExpression(node) {
@@ -101,7 +101,7 @@ module.exports = {
 
         /**
          * Test if the node matches the pattern id ? id : expression
-         * @param {ASTNode} node - The ConditionalExpression to check.
+         * @param {ASTNode} node The ConditionalExpression to check.
          * @returns {boolean} True if the pattern is matched, and false otherwise
          * @private
          */