eslint 6.5.1 → 6.7.2

package/lib/rules/no-invalid-this.js

@@ -26,10 +26,23 @@ module.exports = {
             url: "https://eslint.org/docs/rules/no-invalid-this"
         },
 
-        schema: []
+        schema: [
+            {
+                type: "object",
+                properties: {
+                    capIsConstructor: {
+                        type: "boolean",
+                        default: true
+                    }
+                },
+                additionalProperties: false
+            }
+        ]
     },
 
     create(context) {
+        const options = context.options[0] || {};
+        const capIsConstructor = options.capIsConstructor !== false;
         const stack = [],
             sourceCode = context.getSourceCode();
 
@@ -38,7 +51,6 @@ module.exports = {
          *
          * The return value has a flag that whether or not `this` keyword is valid.
          * The flag is initialized when got at the first time.
-         *
          * @returns {{valid: boolean}}
          *   an object which has a flag that whether or not `this` keyword is valid.
          */
@@ -49,7 +61,8 @@ module.exports = {
                 current.init = true;
                 current.valid = !astUtils.isDefaultThisBinding(
                     current.node,
-                    sourceCode
+                    sourceCode,
+                    { capIsConstructor }
                 );
             }
             return current;
@@ -61,8 +74,7 @@ module.exports = {
          * The checking context is not initialized yet.
          * Because most functions don't have `this` keyword.
          * When `this` keyword was found, the checking context is initialized.
-         *
-         * @param {ASTNode} node - A function node that was entered.
+         * @param {ASTNode} node A function node that was entered.
          * @returns {void}
          */
         function enterFunction(node) {

package/lib/rules/no-labels.js

@@ -51,8 +51,7 @@ module.exports = {
 
         /**
          * Gets the kind of a given node.
-         *
-         * @param {ASTNode} node - A node to get.
+         * @param {ASTNode} node A node to get.
          * @returns {string} The kind of the node.
          */
         function getBodyKind(node) {
@@ -67,8 +66,7 @@ module.exports = {
 
         /**
          * Checks whether the label of a given kind is allowed or not.
-         *
-         * @param {string} kind - A kind to check.
+         * @param {string} kind A kind to check.
          * @returns {boolean} `true` if the kind is allowed.
          */
         function isAllowed(kind) {
@@ -81,8 +79,7 @@ module.exports = {
 
         /**
          * Checks whether a given name is a label of a loop or not.
-         *
-         * @param {string} label - A name of a label to check.
+         * @param {string} label A name of a label to check.
          * @returns {boolean} `true` if the name is a label of a loop.
          */
         function getKind(label) {

package/lib/rules/no-lone-blocks.js

@@ -31,7 +31,7 @@ module.exports = {
 
         /**
          * Reports a node as invalid.
-         * @param {ASTNode} node - The node to be reported.
+         * @param {ASTNode} node The node to be reported.
          * @returns {void}
          */
         function report(node) {

package/lib/rules/no-loop-func.js

@@ -14,8 +14,7 @@
  *
  * We don't need to check nested functions, so this ignores those.
  * `Scope.through` contains references of nested functions.
- *
- * @param {ASTNode} node - An AST node to get.
+ * @param {ASTNode} node An AST node to get.
  * @returns {ASTNode|null} The containing loop node of the specified node, or
  *      `null`.
  */
@@ -63,9 +62,8 @@ function getContainingLoopNode(node) {
 /**
  * Gets the containing loop node of a given node.
  * If the loop was nested, this returns the most outer loop.
- *
- * @param {ASTNode} node - A node to get. This is a loop node.
- * @param {ASTNode|null} excludedNode - A node that the result node should not
+ * @param {ASTNode} node A node to get. This is a loop node.
+ * @param {ASTNode|null} excludedNode A node that the result node should not
  *      include.
  * @returns {ASTNode} The most outer loop node.
  */
@@ -85,9 +83,8 @@ function getTopLoopNode(node, excludedNode) {
 /**
  * Checks whether a given reference which refers to an upper scope's variable is
  * safe or not.
- *
- * @param {ASTNode} loopNode - A containing loop node.
- * @param {eslint-scope.Reference} reference - A reference to check.
+ * @param {ASTNode} loopNode A containing loop node.
+ * @param {eslint-scope.Reference} reference A reference to check.
  * @returns {boolean} `true` if the reference is safe or not.
  */
 function isSafe(loopNode, reference) {
@@ -131,8 +128,7 @@ function isSafe(loopNode, reference) {
      * It's safeafe if the reference matches one of the following condition.
      * - is readonly.
      * - doesn't exist inside a local function and after the border.
-     *
-     * @param {eslint-scope.Reference} upperRef - A reference to check.
+     * @param {eslint-scope.Reference} upperRef A reference to check.
      * @returns {boolean} `true` if the reference is safe.
      */
     function isSafeReference(upperRef) {
@@ -177,7 +173,6 @@ module.exports = {
          *
          * - has a loop node in ancestors.
          * - has any references which refers to an unsafe variable.
-         *
          * @param {ASTNode} node The AST node to check.
          * @returns {boolean} Whether or not the node is within a loop.
          */

package/lib/rules/no-magic-numbers.js

@@ -61,7 +61,7 @@ module.exports = {
 
         /**
          * Returns whether the node is number literal
-         * @param {Node} node - the node literal being evaluated
+         * @param {Node} node the node literal being evaluated
          * @returns {boolean} true if the node is a number literal
          */
         function isNumber(node) {
@@ -70,7 +70,7 @@ module.exports = {
 
         /**
          * Returns whether the number should be ignored
-         * @param {number} num - the number
+         * @param {number} num the number
          * @returns {boolean} true if the number should be ignored
          */
         function shouldIgnoreNumber(num) {
@@ -79,8 +79,8 @@ module.exports = {
 
         /**
          * Returns whether the number should be ignored when used as a radix within parseInt() or Number.parseInt()
-         * @param {ASTNode} parent - the non-"UnaryExpression" parent
-         * @param {ASTNode} node - the node literal being evaluated
+         * @param {ASTNode} parent the non-"UnaryExpression" parent
+         * @param {ASTNode} node the node literal being evaluated
          * @returns {boolean} true if the number should be ignored
          */
         function shouldIgnoreParseInt(parent, node) {
@@ -93,7 +93,7 @@ module.exports = {
 
         /**
          * Returns whether the number should be ignored when used to define a JSX prop
-         * @param {ASTNode} parent - the non-"UnaryExpression" parent
+         * @param {ASTNode} parent the non-"UnaryExpression" parent
          * @returns {boolean} true if the number should be ignored
          */
         function shouldIgnoreJSXNumbers(parent) {
@@ -102,7 +102,7 @@ module.exports = {
 
         /**
          * Returns whether the number should be ignored when used as an array index with enabled 'ignoreArrayIndexes' option.
-         * @param {ASTNode} parent - the non-"UnaryExpression" parent.
+         * @param {ASTNode} parent the non-"UnaryExpression" parent.
          * @returns {boolean} true if the number should be ignored
          */
         function shouldIgnoreArrayIndexes(parent) {

package/lib/rules/no-misleading-character-class.js

@@ -16,7 +16,6 @@ const { isCombiningCharacter, isEmojiModifier, isRegionalIndicatorSymbol, isSurr
  *
  * CharacterClassRange syntax can steal a part of character sequence,
  * so this function reverts CharacterClassRange syntax and restore the sequence.
- *
  * @param {regexpp.AST.CharacterClassElement[]} nodes The node list to iterate character sequences.
  * @returns {IterableIterator<number[]>} The list of character sequences.
  */
@@ -131,12 +130,6 @@ module.exports = {
          * @returns {void}
          */
         function verify(node, pattern, flags) {
-            const patternNode = parser.parsePattern(
-                pattern,
-                0,
-                pattern.length,
-                flags.includes("u")
-            );
             const has = {
                 surrogatePairWithoutUFlag: false,
                 combiningClass: false,
@@ -145,6 +138,20 @@ module.exports = {
                 regionalIndicatorSymbol: false,
                 zwj: false
             };
+            let patternNode;
+
+            try {
+                patternNode = parser.parsePattern(
+                    pattern,
+                    0,
+                    pattern.length,
+                    flags.includes("u")
+                );
+            } catch (e) {
+
+                // Ignore regular expressions with syntax errors
+                return;
+            }
 
             visitRegExpAST(patternNode, {
                 onCharacterClassEnter(ccNode) {

package/lib/rules/no-mixed-operators.js

@@ -40,8 +40,7 @@ const TARGET_NODE_TYPE = /^(?:Binary|Logical|Conditional)Expression$/u;
 
 /**
  * Normalizes options.
- *
- * @param {Object|undefined} options - A options object to normalize.
+ * @param {Object|undefined} options A options object to normalize.
  * @returns {Object} Normalized option object.
  */
 function normalizeOptions(options = {}) {
@@ -57,10 +56,9 @@ function normalizeOptions(options = {}) {
 
 /**
  * Checks whether any group which includes both given operator exists or not.
- *
- * @param {Array.<string[]>} groups - A list of groups to check.
- * @param {string} left - An operator.
- * @param {string} right - Another operator.
+ * @param {Array.<string[]>} groups A list of groups to check.
+ * @param {string} left An operator.
+ * @param {string} right Another operator.
  * @returns {boolean} `true` if such group existed.
  */
 function includesBothInAGroup(groups, left, right) {
@@ -69,8 +67,7 @@ function includesBothInAGroup(groups, left, right) {
 
 /**
  * Checks whether the given node is a conditional expression and returns the test node else the left node.
- *
- * @param {ASTNode} node - A node which can be a BinaryExpression or a LogicalExpression node.
+ * @param {ASTNode} node A node which can be a BinaryExpression or a LogicalExpression node.
  * This parent node can be BinaryExpression, LogicalExpression
  *      , or a ConditionalExpression node
  * @returns {ASTNode} node the appropriate node(left or test).
@@ -124,8 +121,7 @@ module.exports = {
 
         /**
          * Checks whether a given node should be ignored by options or not.
-         *
-         * @param {ASTNode} node - A node to check. This is a BinaryExpression
+         * @param {ASTNode} node A node to check. This is a BinaryExpression
          *      node or a LogicalExpression node. This parent node is one of
          *      them, too.
          * @returns {boolean} `true` if the node should be ignored.
@@ -146,8 +142,7 @@ module.exports = {
         /**
          * Checks whether the operator of a given node is mixed with parent
          * node's operator or not.
-         *
-         * @param {ASTNode} node - A node to check. This is a BinaryExpression
+         * @param {ASTNode} node A node to check. This is a BinaryExpression
          *      node or a LogicalExpression node. This parent node is one of
          *      them, too.
          * @returns {boolean} `true` if the node was mixed.
@@ -163,8 +158,7 @@ module.exports = {
         /**
          * Checks whether the operator of a given node is mixed with a
          * conditional expression.
-         *
-         * @param {ASTNode} node - A node to check. This is a conditional
+         * @param {ASTNode} node A node to check. This is a conditional
          *      expression node
          * @returns {boolean} `true` if the node was mixed.
          */
@@ -174,8 +168,7 @@ module.exports = {
 
         /**
          * Gets the operator token of a given node.
-         *
-         * @param {ASTNode} node - A node to check. This is a BinaryExpression
+         * @param {ASTNode} node A node to check. This is a BinaryExpression
          *      node or a LogicalExpression node.
          * @returns {Token} The operator token of the node.
          */
@@ -186,8 +179,7 @@ module.exports = {
         /**
          * Reports both the operator of a given node and the operator of the
          * parent node.
-         *
-         * @param {ASTNode} node - A node to check. This is a BinaryExpression
+         * @param {ASTNode} node A node to check. This is a BinaryExpression
          *      node or a LogicalExpression node. This parent node is one of
          *      them, too.
          * @returns {void}
@@ -205,13 +197,13 @@ module.exports = {
 
             context.report({
                 node: left,
-                loc: getOperatorToken(left).loc.start,
+                loc: getOperatorToken(left).loc,
                 message,
                 data
             });
             context.report({
                 node: right,
-                loc: getOperatorToken(right).loc.start,
+                loc: getOperatorToken(right).loc,
                 message,
                 data
             });
@@ -220,8 +212,7 @@ module.exports = {
         /**
          * Checks between the operator of this node and the operator of the
          * parent node.
-         *
-         * @param {ASTNode} node - A node to check.
+         * @param {ASTNode} node A node to check.
          * @returns {void}
          */
         function check(node) {

package/lib/rules/no-mixed-requires.js

@@ -58,7 +58,6 @@ module.exports = {
 
         /**
          * Returns the list of built-in modules.
-         *
          * @returns {string[]} An array of built-in Node.js modules.
          */
         function getBuiltinModules() {

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

@@ -121,7 +121,7 @@ module.exports = {
 
                     context.report({
                         node: rightToken,
-                        loc: rightToken.loc.start,
+                        loc: { start: leftToken.loc.end, end: rightToken.loc.start },
                         message: "Multiple spaces found before '{{displayValue}}'.",
                         data: { displayValue },
                         fix: fixer => fixer.replaceTextRange([leftToken.range[1], rightToken.range[0]], " ")

package/lib/rules/no-native-reassign.js

@@ -46,9 +46,9 @@ module.exports = {
 
         /**
          * Reports write references.
-         * @param {Reference} reference - A reference to check.
-         * @param {int} index - The index of the reference in the references.
-         * @param {Reference[]} references - The array that the reference belongs to.
+         * @param {Reference} reference A reference to check.
+         * @param {int} index The index of the reference in the references.
+         * @param {Reference[]} references The array that the reference belongs to.
          * @returns {void}
          */
         function checkReference(reference, index, references) {
@@ -73,7 +73,7 @@ module.exports = {
 
         /**
          * Reports write references if a given variable is read-only builtin.
-         * @param {Variable} variable - A variable to check.
+         * @param {Variable} variable A variable to check.
          * @returns {void}
          */
         function checkVariable(variable) {

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

@@ -38,7 +38,7 @@ module.exports = {
 
                 // \0 represents a valid NULL character if it isn't followed by a digit.
                 const match = node.raw.match(
-                    /^(?:[^\\]|\\.)*?\\([0-3][0-7]{1,2}|[4-7][0-7]|[1-7])/u
+                    /^(?:[^\\]|\\.)*?\\([0-3][0-7]{1,2}|[4-7][0-7]|0(?=[89])|[1-7])/su
                 );
 
                 if (match) {

package/lib/rules/no-param-reassign.js

@@ -45,6 +45,13 @@ module.exports = {
                                     type: "string"
                                 },
                                 uniqueItems: true
+                            },
+                            ignorePropertyModificationsForRegex: {
+                                type: "array",
+                                items: {
+                                    type: "string"
+                                },
+                                uniqueItems: true
                             }
                         },
                         additionalProperties: false
@@ -57,10 +64,11 @@ module.exports = {
     create(context) {
         const props = context.options[0] && context.options[0].props;
         const ignoredPropertyAssignmentsFor = context.options[0] && context.options[0].ignorePropertyModificationsFor || [];
+        const ignoredPropertyAssignmentsForRegex = context.options[0] && context.options[0].ignorePropertyModificationsForRegex || [];
 
         /**
          * Checks whether or not the reference modifies properties of its variable.
-         * @param {Reference} reference - A reference to check.
+         * @param {Reference} reference A reference to check.
          * @returns {boolean} Whether or not the reference modifies properties of its variable.
          */
         function isModifyingProp(reference) {
@@ -136,11 +144,24 @@ module.exports = {
             return false;
         }
 
+        /**
+         * Tests that an identifier name matches any of the ignored property assignments.
+         * First we test strings in ignoredPropertyAssignmentsFor.
+         * Then we instantiate and test RegExp objects from ignoredPropertyAssignmentsForRegex strings.
+         * @param {string} identifierName A string that describes the name of an identifier to
+         * ignore property assignments for.
+         * @returns {boolean} Whether the string matches an ignored property assignment regular expression or not.
+         */
+        function isIgnoredPropertyAssignment(identifierName) {
+            return ignoredPropertyAssignmentsFor.includes(identifierName) ||
+                ignoredPropertyAssignmentsForRegex.some(ignored => new RegExp(ignored, "u").test(identifierName));
+        }
+
         /**
          * Reports a reference if is non initializer and writable.
-         * @param {Reference} reference - A reference to check.
-         * @param {int} index - The index of the reference in the references.
-         * @param {Reference[]} references - The array that the reference belongs to.
+         * @param {Reference} reference A reference to check.
+         * @param {int} index The index of the reference in the references.
+         * @param {Reference[]} references The array that the reference belongs to.
          * @returns {void}
          */
         function checkReference(reference, index, references) {
@@ -157,7 +178,7 @@ module.exports = {
             ) {
                 if (reference.isWrite()) {
                     context.report({ node: identifier, message: "Assignment to function parameter '{{name}}'.", data: { name: identifier.name } });
-                } else if (props && isModifyingProp(reference) && ignoredPropertyAssignmentsFor.indexOf(identifier.name) === -1) {
+                } else if (props && isModifyingProp(reference) && !isIgnoredPropertyAssignment(identifier.name)) {
                     context.report({ node: identifier, message: "Assignment to property of function parameter '{{name}}'.", data: { name: identifier.name } });
                 }
             }
@@ -165,7 +186,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) {
@@ -176,7 +197,7 @@ module.exports = {
 
         /**
          * Checks parameters of a given function node.
-         * @param {ASTNode} node - A function node to check.
+         * @param {ASTNode} node A function node to check.
          * @returns {void}
          */
         function checkForFunction(node) {

package/lib/rules/no-redeclare.js

@@ -86,7 +86,7 @@ module.exports = {
 
         /**
          * Find variables in a given scope and flag redeclared ones.
-         * @param {Scope} scope - An eslint-scope scope object.
+         * @param {Scope} scope An eslint-scope scope object.
          * @returns {void}
          * @private
          */

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

@@ -52,7 +52,6 @@ module.exports = {
 
         /**
          * Validate regular expression
-         *
          * @param {ASTNode} nodeToReport Node to report.
          * @param {string} pattern Regular expression pattern to validate.
          * @param {string} rawPattern Raw representation of the pattern in the source code.

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) {