eslint 6.3.0 → 6.6.0

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

@@ -29,7 +29,7 @@ module.exports = {
 
         /**
          * Reports a reference if is non initializer and writable.
-         * @param {References} references - Collection of reference to check.
+         * @param {References} references Collection of reference to check.
          * @returns {void}
          */
         function checkReference(references) {
@@ -40,7 +40,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) {
@@ -51,7 +51,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-global-assign.js

@@ -41,9 +41,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) {
@@ -68,7 +68,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-implicit-coercion.js

@@ -16,7 +16,7 @@ const ALLOWABLE_OPERATORS = ["~", "!!", "+", "*"];
 
 /**
  * Parses and normalizes an option object.
- * @param {Object} options - An option object to parse.
+ * @param {Object} options An option object to parse.
  * @returns {Object} The parsed and normalized option object.
  */
 function parseOptions(options) {
@@ -30,7 +30,7 @@ function parseOptions(options) {
 
 /**
  * Checks whether or not a node is a double logical nigating.
- * @param {ASTNode} node - An UnaryExpression node to check.
+ * @param {ASTNode} node An UnaryExpression node to check.
  * @returns {boolean} Whether or not the node is a double logical nigating.
  */
 function isDoubleLogicalNegating(node) {
@@ -43,7 +43,7 @@ function isDoubleLogicalNegating(node) {
 
 /**
  * Checks whether or not a node is a binary negating of `.indexOf()` method calling.
- * @param {ASTNode} node - An UnaryExpression node to check.
+ * @param {ASTNode} node An UnaryExpression node to check.
  * @returns {boolean} Whether or not the node is a binary negating of `.indexOf()` method calling.
  */
 function isBinaryNegatingOfIndexOf(node) {
@@ -58,7 +58,7 @@ function isBinaryNegatingOfIndexOf(node) {
 
 /**
  * Checks whether or not a node is a multiplying by one.
- * @param {BinaryExpression} node - A BinaryExpression node to check.
+ * @param {BinaryExpression} node A BinaryExpression node to check.
  * @returns {boolean} Whether or not the node is a multiplying by one.
  */
 function isMultiplyByOne(node) {
@@ -118,7 +118,7 @@ function isEmptyString(node) {
 
 /**
  * Checks whether or not a node is a concatenating with an empty string.
- * @param {ASTNode} node - A BinaryExpression node to check.
+ * @param {ASTNode} node A BinaryExpression node to check.
  * @returns {boolean} Whether or not the node is a concatenating with an empty string.
  */
 function isConcatWithEmptyString(node) {
@@ -130,7 +130,7 @@ function isConcatWithEmptyString(node) {
 
 /**
  * Checks whether or not a node is appended with an empty string.
- * @param {ASTNode} node - An AssignmentExpression node to check.
+ * @param {ASTNode} node An AssignmentExpression node to check.
  * @returns {boolean} Whether or not the node is appended with an empty string.
  */
 function isAppendEmptyString(node) {
@@ -139,7 +139,7 @@ function isAppendEmptyString(node) {
 
 /**
  * Returns the operand that is not an empty string from a flagged BinaryExpression.
- * @param {ASTNode} node - The flagged BinaryExpression node to check.
+ * @param {ASTNode} node The flagged BinaryExpression node to check.
  * @returns {ASTNode} The operand that is not an empty string from a flagged BinaryExpression.
  */
 function getNonEmptyOperand(node) {
@@ -196,9 +196,9 @@ module.exports = {
 
         /**
          * Reports an error and autofixes the node
-         * @param {ASTNode} node - An ast node to report the error on.
-         * @param {string} recommendation - The recommended code for the issue
-         * @param {bool} shouldFix - Whether this report should fix the node
+         * @param {ASTNode} node An ast node to report the error on.
+         * @param {string} recommendation The recommended code for the issue
+         * @param {bool} shouldFix Whether this report should fix the node
          * @returns {void}
          */
         function report(node, recommendation, shouldFix) {

package/lib/rules/no-implied-eval.js

@@ -64,7 +64,6 @@ module.exports = {
          * Determines if a node represents a call to a potentially implied eval.
          *
          * This checks the callee name and that there's an argument, but not the type of the argument.
-         *
          * @param {ASTNode} node The CallExpression to check.
          * @returns {boolean} True if the node matches, false if not.
          * @private

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

@@ -0,0 +1,238 @@
+/**
+ * @fileoverview Rule to flag updates of imported bindings.
+ * @author Toru Nagashima <https://github.com/mysticatea>
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+const { findVariable, getPropertyName } = require("eslint-utils");
+
+const MutationMethods = {
+    Object: new Set([
+        "assign", "defineProperties", "defineProperty", "freeze",
+        "setPrototypeOf"
+    ]),
+    Reflect: new Set([
+        "defineProperty", "deleteProperty", "set", "setPrototypeOf"
+    ])
+};
+
+/**
+ * Check if a given node is LHS of an assignment node.
+ * @param {ASTNode} node The node to check.
+ * @returns {boolean} `true` if the node is LHS.
+ */
+function isAssignmentLeft(node) {
+    const { parent } = node;
+
+    return (
+        (
+            parent.type === "AssignmentExpression" &&
+            parent.left === node
+        ) ||
+
+        // Destructuring assignments
+        parent.type === "ArrayPattern" ||
+        (
+            parent.type === "Property" &&
+            parent.value === node &&
+            parent.parent.type === "ObjectPattern"
+        ) ||
+        parent.type === "RestElement" ||
+        (
+            parent.type === "AssignmentPattern" &&
+            parent.left === node
+        )
+    );
+}
+
+/**
+ * Check if a given node is the operand of mutation unary operator.
+ * @param {ASTNode} node The node to check.
+ * @returns {boolean} `true` if the node is the operand of mutation unary operator.
+ */
+function isOperandOfMutationUnaryOperator(node) {
+    const { parent } = node;
+
+    return (
+        (
+            parent.type === "UpdateExpression" &&
+            parent.argument === node
+        ) ||
+        (
+            parent.type === "UnaryExpression" &&
+            parent.operator === "delete" &&
+            parent.argument === node
+        )
+    );
+}
+
+/**
+ * Check if a given node is the iteration variable of `for-in`/`for-of` syntax.
+ * @param {ASTNode} node The node to check.
+ * @returns {boolean} `true` if the node is the iteration variable.
+ */
+function isIterationVariable(node) {
+    const { parent } = node;
+
+    return (
+        (
+            parent.type === "ForInStatement" &&
+            parent.left === node
+        ) ||
+        (
+            parent.type === "ForOfStatement" &&
+            parent.left === node
+        )
+    );
+}
+
+/**
+ * Check if a given node is the iteration variable of `for-in`/`for-of` syntax.
+ * @param {ASTNode} node The node to check.
+ * @param {Scope} scope A `escope.Scope` object to find variable (whichever).
+ * @returns {boolean} `true` if the node is the iteration variable.
+ */
+function isArgumentOfWellKnownMutationFunction(node, scope) {
+    const { parent } = node;
+
+    if (
+        parent.type === "CallExpression" &&
+        parent.arguments[0] === node &&
+        parent.callee.type === "MemberExpression" &&
+        parent.callee.object.type === "Identifier"
+    ) {
+        const { callee } = parent;
+        const { object } = callee;
+
+        if (Object.keys(MutationMethods).includes(object.name)) {
+            const variable = findVariable(scope, object);
+
+            return (
+                variable !== null &&
+                variable.scope.type === "global" &&
+                MutationMethods[object.name].has(getPropertyName(callee, scope))
+            );
+        }
+    }
+
+    return false;
+}
+
+/**
+ * Check if the identifier node is placed at to update members.
+ * @param {ASTNode} id The Identifier node to check.
+ * @param {Scope} scope A `escope.Scope` object to find variable (whichever).
+ * @returns {boolean} `true` if the member of `id` was updated.
+ */
+function isMemberWrite(id, scope) {
+    const { parent } = id;
+
+    return (
+        (
+            parent.type === "MemberExpression" &&
+            parent.object === id &&
+            (
+                isAssignmentLeft(parent) ||
+                isOperandOfMutationUnaryOperator(parent) ||
+                isIterationVariable(parent)
+            )
+        ) ||
+        isArgumentOfWellKnownMutationFunction(id, scope)
+    );
+}
+
+/**
+ * Get the mutation node.
+ * @param {ASTNode} id The Identifier node to get.
+ * @returns {ASTNode} The mutation node.
+ */
+function getWriteNode(id) {
+    let node = id.parent;
+
+    while (
+        node &&
+        node.type !== "AssignmentExpression" &&
+        node.type !== "UpdateExpression" &&
+        node.type !== "UnaryExpression" &&
+        node.type !== "CallExpression" &&
+        node.type !== "ForInStatement" &&
+        node.type !== "ForOfStatement"
+    ) {
+        node = node.parent;
+    }
+
+    return node || id;
+}
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = {
+    meta: {
+        type: "problem",
+
+        docs: {
+            description: "disallow assigning to imported bindings",
+            category: "Possible Errors",
+            recommended: false,
+            url: "https://eslint.org/docs/rules/no-import-assign"
+        },
+
+        schema: [],
+
+        messages: {
+            readonly: "'{{name}}' is read-only.",
+            readonlyMember: "The members of '{{name}}' are read-only."
+        }
+    },
+
+    create(context) {
+        return {
+            ImportDeclaration(node) {
+                const scope = context.getScope();
+
+                for (const variable of context.getDeclaredVariables(node)) {
+                    const shouldCheckMembers = variable.defs.some(
+                        d => d.node.type === "ImportNamespaceSpecifier"
+                    );
+                    let prevIdNode = null;
+
+                    for (const reference of variable.references) {
+                        const idNode = reference.identifier;
+
+                        /*
+                         * AssignmentPattern (e.g. `[a = 0] = b`) makes two write
+                         * references for the same identifier. This should skip
+                         * the one of the two in order to prevent redundant reports.
+                         */
+                        if (idNode === prevIdNode) {
+                            continue;
+                        }
+                        prevIdNode = idNode;
+
+                        if (reference.isWrite()) {
+                            context.report({
+                                node: getWriteNode(idNode),
+                                messageId: "readonly",
+                                data: { name: idNode.name }
+                            });
+                        } else if (shouldCheckMembers && isMemberWrite(idNode, scope)) {
+                            context.report({
+                                node: getWriteNode(idNode),
+                                messageId: "readonlyMember",
+                                data: { name: idNode.name }
+                            });
+                        }
+                    }
+                }
+            }
+        };
+
+    }
+};

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

@@ -38,7 +38,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.
          */
@@ -61,8 +60,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) {
@@ -79,7 +79,7 @@ module.exports = {
             }
         };
 
-        // ES6: report blocks without block-level bindings
+        // ES6: report blocks without block-level bindings, or that's only child of another block
         if (context.parserOptions.ecmaVersion >= 6) {
             ruleDef = {
                 BlockStatement(node) {
@@ -91,6 +91,11 @@ module.exports = {
                     if (loneBlocks.length > 0 && loneBlocks[loneBlocks.length - 1] === node) {
                         loneBlocks.pop();
                         report(node);
+                    } else if (
+                        node.parent.type === "BlockStatement" &&
+                        node.parent.body.length === 1
+                    ) {
+                        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) {