eslint 6.5.1 → 6.6.0

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

@@ -116,7 +116,7 @@ module.exports = {
 
         /**
          * Checks to see if "*" is being used to import everything.
-         * @param {Set.<string>} importNames - Set of import names that are being imported
+         * @param {Set.<string>} importNames Set of import names that are being imported
          * @returns {boolean} whether everything is imported or not
          */
         function isEverythingImported(importNames) {
@@ -145,7 +145,7 @@ module.exports = {
 
         /**
          * Report a restricted path specifically for patterns.
-         * @param {node} node - representing the restricted path reference
+         * @param {node} node representing the restricted path reference
          * @returns {void}
          * @private
          */
@@ -163,8 +163,8 @@ module.exports = {
 
         /**
          * Report a restricted path specifically when using the '*' import.
-         * @param {string} importSource - path of the import
-         * @param {node} node - representing the restricted path reference
+         * @param {string} importSource path of the import
+         * @param {node} node representing the restricted path reference
          * @returns {void}
          * @private
          */
@@ -185,8 +185,8 @@ module.exports = {
 
         /**
          * Check if the given importSource is restricted because '*' is being imported.
-         * @param {string} importSource - path of the import
-         * @param {Set.<string>} importNames - Set of import names that are being imported
+         * @param {string} importSource path of the import
+         * @param {Set.<string>} importNames Set of import names that are being imported
          * @returns {boolean} whether the path is restricted
          * @private
          */
@@ -198,8 +198,8 @@ module.exports = {
 
         /**
          * Check if the given importNames are restricted given a list of restrictedImportNames.
-         * @param {Set.<string>} importNames - Set of import names that are being imported
-         * @param {string[]} restrictedImportNames - array of import names that are restricted for this import
+         * @param {Set.<string>} importNames Set of import names that are being imported
+         * @param {string[]} restrictedImportNames array of import names that are restricted for this import
          * @returns {boolean} whether the objectName is restricted
          * @private
          */
@@ -211,8 +211,8 @@ module.exports = {
 
         /**
          * Check if the given importSource is a restricted path.
-         * @param {string} importSource - path of the import
-         * @param {Set.<string>} importNames - Set of import names that are being imported
+         * @param {string} importSource path of the import
+         * @param {Set.<string>} importNames Set of import names that are being imported
          * @returns {boolean} whether the variable is a restricted path or not
          * @private
          */
@@ -232,7 +232,7 @@ module.exports = {
 
         /**
          * Check if the given importSource is restricted by a pattern.
-         * @param {string} importSource - path of the import
+         * @param {string} importSource path of the import
          * @returns {boolean} whether the variable is a restricted pattern or not
          * @private
          */

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

@@ -20,9 +20,8 @@ const SPACES = /\s+/gu;
 /**
  * Checks whether the property of 2 given member expression nodes are the same
  * property or not.
- *
- * @param {ASTNode} left - A member expression node to check.
- * @param {ASTNode} right - Another member expression node to check.
+ * @param {ASTNode} left A member expression node to check.
+ * @param {ASTNode} right Another member expression node to check.
  * @returns {boolean} `true` if the member expressions have the same property.
  */
 function isSameProperty(left, right) {
@@ -43,9 +42,8 @@ function isSameProperty(left, right) {
 /**
  * Checks whether 2 given member expression nodes are the reference to the same
  * property or not.
- *
- * @param {ASTNode} left - A member expression node to check.
- * @param {ASTNode} right - Another member expression node to check.
+ * @param {ASTNode} left A member expression node to check.
+ * @param {ASTNode} right Another member expression node to check.
  * @returns {boolean} `true` if the member expressions are the reference to the
  *  same property or not.
  */
@@ -63,18 +61,20 @@ function isSameMember(left, right) {
     if (lobj.type === "MemberExpression") {
         return isSameMember(lobj, robj);
     }
+    if (lobj.type === "ThisExpression") {
+        return true;
+    }
     return lobj.type === "Identifier" && lobj.name === robj.name;
 }
 
 /**
  * Traverses 2 Pattern nodes in parallel, then reports self-assignments.
- *
- * @param {ASTNode|null} left - A left node to traverse. This is a Pattern or
+ * @param {ASTNode|null} left A left node to traverse. This is a Pattern or
  *      a Property.
- * @param {ASTNode|null} right - A right node to traverse. This is a Pattern or
+ * @param {ASTNode|null} right A right node to traverse. This is a Pattern or
  *      a Property.
- * @param {boolean} props - The flag to check member expressions as well.
- * @param {Function} report - A callback function to report.
+ * @param {boolean} props The flag to check member expressions as well.
+ * @param {Function} report A callback function to report.
  * @returns {void}
  */
 function eachSelfAssignment(left, right, props, report) {
@@ -205,8 +205,7 @@ module.exports = {
 
         /**
          * Reports a given node as self assignments.
-         *
-         * @param {ASTNode} node - A node to report. This is an Identifier node.
+         * @param {ASTNode} node A node to report. This is an Identifier node.
          * @returns {void}
          */
         function report(node) {

package/lib/rules/no-sequences.js

@@ -54,7 +54,7 @@ module.exports = {
         /**
          * Determines whether a node is required by the grammar to be wrapped in
          * parens, e.g. the test of an if statement.
-         * @param {ASTNode} node - The AST node
+         * @param {ASTNode} node The AST node
          * @returns {boolean} True if parens around node belong to parent node.
          */
         function requiresExtraParens(node) {
@@ -64,7 +64,7 @@ module.exports = {
 
         /**
          * Check if a node is wrapped in parens.
-         * @param {ASTNode} node - The AST node
+         * @param {ASTNode} node The AST node
          * @returns {boolean} True if the node has a paren on each side.
          */
         function isParenthesised(node) {
@@ -73,7 +73,7 @@ module.exports = {
 
         /**
          * Check if a node is wrapped in two levels of parens.
-         * @param {ASTNode} node - The AST node
+         * @param {ASTNode} node The AST node
          * @returns {boolean} True if two parens surround the node on each side.
          */
         function isParenthesisedTwice(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-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
          */

package/lib/rules/no-unreachable.js

@@ -10,7 +10,7 @@
 
 /**
  * Checks whether or not a given variable declarator has the initializer.
- * @param {ASTNode} node - A VariableDeclarator node to check.
+ * @param {ASTNode} node A VariableDeclarator node to check.
  * @returns {boolean} `true` if the node has the initializer.
  */
 function isInitialized(node) {
@@ -19,7 +19,7 @@ function isInitialized(node) {
 
 /**
  * Checks whether or not a given code path segment is unreachable.
- * @param {CodePathSegment} segment - A CodePathSegment to check.
+ * @param {CodePathSegment} segment A CodePathSegment to check.
  * @returns {boolean} `true` if the segment is unreachable.
  */
 function isUnreachable(segment) {
@@ -57,7 +57,7 @@ class ConsecutiveRange {
 
     /**
      * Checks whether the given node is inside of this range.
-     * @param {ASTNode|Token} node - The node to check.
+     * @param {ASTNode|Token} node The node to check.
      * @returns {boolean} `true` if the node is inside of this range.
      */
     contains(node) {
@@ -69,7 +69,7 @@ class ConsecutiveRange {
 
     /**
      * Checks whether the given node is consecutive to this range.
-     * @param {ASTNode} node - The node to check.
+     * @param {ASTNode} node The node to check.
      * @returns {boolean} `true` if the node is consecutive to this range.
      */
     isConsecutive(node) {
@@ -78,7 +78,7 @@ class ConsecutiveRange {
 
     /**
      * Merges the given node to this range.
-     * @param {ASTNode} node - The node to merge.
+     * @param {ASTNode} node The node to merge.
      * @returns {void}
      */
     merge(node) {
@@ -87,7 +87,7 @@ class ConsecutiveRange {
 
     /**
      * Resets this range by the given node or null.
-     * @param {ASTNode|null} node - The node to reset, or null.
+     * @param {ASTNode|null} node The node to reset, or null.
      * @returns {void}
      */
     reset(node) {
@@ -120,7 +120,7 @@ module.exports = {
 
         /**
          * Reports a given node if it's unreachable.
-         * @param {ASTNode} node - A statement node to report.
+         * @param {ASTNode} node A statement node to report.
          * @returns {void}
          */
         function reportIfUnreachable(node) {

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

@@ -35,8 +35,7 @@ module.exports = {
 
         /**
          * Checks if the node is the finalizer of a TryStatement
-         *
-         * @param {ASTNode} node - node to check.
+         * @param {ASTNode} node node to check.
          * @returns {boolean} - true if the node is the finalizer of a TryStatement
          */
         function isFinallyBlock(node) {
@@ -45,9 +44,8 @@ module.exports = {
 
         /**
          * Climbs up the tree if the node is not a sentinel node
-         *
-         * @param {ASTNode} node - node to check.
-         * @param {string} label - label of the break or continue statement
+         * @param {ASTNode} node node to check.
+         * @param {string} label label of the break or continue statement
          * @returns {boolean} - return whether the node is a finally block or a sentinel node
          */
         function isInFinallyBlock(node, label) {
@@ -82,8 +80,7 @@ module.exports = {
 
         /**
          * Checks whether the possibly-unsafe statement is inside a finally block.
-         *
-         * @param {ASTNode} node - node to check.
+         * @param {ASTNode} node node to check.
          * @returns {void}
          */
         function check(node) {