eslint 7.0.0-alpha.1 → 7.0.0

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

@@ -5,6 +5,13 @@
 
 "use strict";
 
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("./utils/ast-utils");
+const { getStaticValue } = require("eslint-utils");
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -28,94 +35,97 @@ module.exports = {
     },
 
     create(context) {
-        const CALLEE_RE = /^(setTimeout|setInterval|execScript)$/u;
-
-        /*
-         * Figures out if we should inspect a given binary expression. Is a stack
-         * of stacks, where the first element in each substack is a CallExpression.
-         */
-        const impliedEvalAncestorsStack = [];
-
-        //--------------------------------------------------------------------------
-        // Helpers
-        //--------------------------------------------------------------------------
+        const EVAL_LIKE_FUNCS = Object.freeze(["setTimeout", "execScript", "setInterval"]);
+        const GLOBAL_CANDIDATES = Object.freeze(["global", "window", "globalThis"]);
 
         /**
-         * Get the last element of an array, without modifying arr, like pop(), but non-destructive.
-         * @param {Array} arr What to inspect
-         * @returns {*} The last element of arr
-         * @private
+         * Checks whether a node is evaluated as a string or not.
+         * @param {ASTNode} node A node to check.
+         * @returns {boolean} True if the node is evaluated as a string.
          */
-        function last(arr) {
-            return arr ? arr[arr.length - 1] : null;
+        function isEvaluatedString(node) {
+            if (
+                (node.type === "Literal" && typeof node.value === "string") ||
+                node.type === "TemplateLiteral"
+            ) {
+                return true;
+            }
+            if (node.type === "BinaryExpression" && node.operator === "+") {
+                return isEvaluatedString(node.left) || isEvaluatedString(node.right);
+            }
+            return false;
         }
 
         /**
-         * Checks if the given MemberExpression node is a potentially implied eval identifier on window.
-         * @param {ASTNode} node The MemberExpression node to check.
-         * @returns {boolean} Whether or not the given node is potentially an implied eval.
-         * @private
+         * Checks whether a node is an Identifier node named one of the specified names.
+         * @param {ASTNode} node A node to check.
+         * @param {string[]} specifiers Array of specified name.
+         * @returns {boolean} True if the node is a Identifier node which has specified name.
          */
-        function isImpliedEvalMemberExpression(node) {
-            const object = node.object,
-                property = node.property,
-                hasImpliedEvalName = CALLEE_RE.test(property.name) || CALLEE_RE.test(property.value);
-
-            return object.name === "window" && hasImpliedEvalName;
+        function isSpecifiedIdentifier(node, specifiers) {
+            return node.type === "Identifier" && specifiers.includes(node.name);
         }
 
         /**
-         * 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
+         * Checks a given node is a MemberExpression node which has the specified name's
+         * property.
+         * @param {ASTNode} node A node to check.
+         * @param {string[]} specifiers Array of specified name.
+         * @returns {boolean} `true` if the node is a MemberExpression node which has
+         *      the specified name's property
          */
-        function isImpliedEvalCallExpression(node) {
-            const isMemberExpression = (node.callee.type === "MemberExpression"),
-                isIdentifier = (node.callee.type === "Identifier"),
-                isImpliedEvalCallee =
-                    (isIdentifier && CALLEE_RE.test(node.callee.name)) ||
-                    (isMemberExpression && isImpliedEvalMemberExpression(node.callee));
-
-            return isImpliedEvalCallee && node.arguments.length;
+        function isSpecifiedMember(node, specifiers) {
+            return node.type === "MemberExpression" && specifiers.includes(astUtils.getStaticPropertyName(node));
         }
 
         /**
-         * Checks that the parent is a direct descendent of an potential implied eval CallExpression, and if the parent is a CallExpression, that we're the first argument.
-         * @param {ASTNode} node The node to inspect the parent of.
-         * @returns {boolean} Was the parent a direct descendent, and is the child therefore potentially part of a dangerous argument?
-         * @private
+         * Reports if the `CallExpression` node has evaluated argument.
+         * @param {ASTNode} node A CallExpression to check.
+         * @returns {void}
          */
-        function hasImpliedEvalParent(node) {
+        function reportImpliedEvalCallExpression(node) {
+            const [firstArgument] = node.arguments;
 
-            // make sure our parent is marked
-            return node.parent === last(last(impliedEvalAncestorsStack)) &&
+            if (firstArgument) {
+
+                const staticValue = getStaticValue(firstArgument, context.getScope());
+                const isStaticString = staticValue && typeof staticValue.value === "string";
+                const isString = isStaticString || isEvaluatedString(firstArgument);
+
+                if (isString) {
+                    context.report({
+                        node,
+                        messageId: "impliedEval"
+                    });
+                }
+            }
 
-                // if our parent is a CallExpression, make sure we're the first argument
-                (node.parent.type !== "CallExpression" || node === node.parent.arguments[0]);
         }
 
         /**
-         * Checks if our parent is marked as part of an implied eval argument. If
-         * so, collapses the top of impliedEvalAncestorsStack and reports on the
-         * original CallExpression.
-         * @param {ASTNode} node The CallExpression to check.
-         * @returns {boolean} True if the node matches, false if not.
-         * @private
+         * Reports calls of `implied eval` via the global references.
+         * @param {Variable} globalVar A global variable to check.
+         * @returns {void}
          */
-        function checkString(node) {
-            if (hasImpliedEvalParent(node)) {
+        function reportImpliedEvalViaGlobal(globalVar) {
+            const { references, name } = globalVar;
 
-                // remove the entire substack, to avoid duplicate reports
-                const substack = impliedEvalAncestorsStack.pop();
+            references.forEach(ref => {
+                const identifier = ref.identifier;
+                let node = identifier.parent;
 
-                context.report({
-                    node: substack[0],
-                    messageId: "impliedEval"
-                });
-            }
+                while (isSpecifiedMember(node, [name])) {
+                    node = node.parent;
+                }
+
+                if (isSpecifiedMember(node, EVAL_LIKE_FUNCS)) {
+                    const parent = node.parent;
+
+                    if (parent.type === "CallExpression" && parent.callee === node) {
+                        reportImpliedEvalCallExpression(parent);
+                    }
+                }
+            });
         }
 
         //--------------------------------------------------------------------------
@@ -124,45 +134,17 @@ module.exports = {
 
         return {
             CallExpression(node) {
-                if (isImpliedEvalCallExpression(node)) {
-
-                    // call expressions create a new substack
-                    impliedEvalAncestorsStack.push([node]);
-                }
-            },
-
-            "CallExpression:exit"(node) {
-                if (node === last(last(impliedEvalAncestorsStack))) {
-
-                    /*
-                     * Destroys the entire sub-stack, rather than just using
-                     * last(impliedEvalAncestorsStack).pop(), as a CallExpression is
-                     * always the bottom of a impliedEvalAncestorsStack substack.
-                     */
-                    impliedEvalAncestorsStack.pop();
-                }
-            },
-
-            BinaryExpression(node) {
-                if (node.operator === "+" && hasImpliedEvalParent(node)) {
-                    last(impliedEvalAncestorsStack).push(node);
-                }
-            },
-
-            "BinaryExpression:exit"(node) {
-                if (node === last(last(impliedEvalAncestorsStack))) {
-                    last(impliedEvalAncestorsStack).pop();
-                }
-            },
-
-            Literal(node) {
-                if (typeof node.value === "string") {
-                    checkString(node);
+                if (isSpecifiedIdentifier(node.callee, EVAL_LIKE_FUNCS)) {
+                    reportImpliedEvalCallExpression(node);
                 }
             },
+            "Program:exit"() {
+                const globalScope = context.getScope();
 
-            TemplateLiteral(node) {
-                checkString(node);
+                GLOBAL_CANDIDATES
+                    .map(candidate => astUtils.getVariableByName(globalScope, candidate))
+                    .filter(globalVar => !!globalVar && globalVar.defs.length === 0)
+                    .forEach(reportImpliedEvalViaGlobal);
             }
         };
 

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

@@ -180,7 +180,7 @@ module.exports = {
         docs: {
             description: "disallow assigning to imported bindings",
             category: "Possible Errors",
-            recommended: false,
+            recommended: true,
             url: "https://eslint.org/docs/rules/no-import-assign"
         },
 

package/lib/rules/no-inner-declarations.js

@@ -5,10 +5,19 @@
 
 "use strict";
 
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("./utils/ast-utils");
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
 
+const validParent = new Set(["Program", "ExportNamedDeclaration", "ExportDefaultDeclaration"]);
+const validBlockStatementParent = new Set(["FunctionDeclaration", "FunctionExpression", "ArrowFunctionExpression"]);
+
 module.exports = {
     meta: {
         type: "problem",
@@ -33,54 +42,37 @@ module.exports = {
 
     create(context) {
 
-        /**
-         * Find the nearest Program or Function ancestor node.
-         * @returns {Object} Ancestor's type and distance from node.
-         */
-        function nearestBody() {
-            const ancestors = context.getAncestors();
-            let ancestor = ancestors.pop(),
-                generation = 1;
-
-            while (ancestor && ["Program", "FunctionDeclaration",
-                "FunctionExpression", "ArrowFunctionExpression"
-            ].indexOf(ancestor.type) < 0) {
-                generation += 1;
-                ancestor = ancestors.pop();
-            }
-
-            return {
-
-                // Type of containing ancestor
-                type: ancestor.type,
-
-                // Separation between ancestor and node
-                distance: generation
-            };
-        }
-
         /**
          * Ensure that a given node is at a program or function body's root.
          * @param {ASTNode} node Declaration node to check.
          * @returns {void}
          */
         function check(node) {
-            const body = nearestBody(),
-                valid = ((body.type === "Program" && body.distance === 1) ||
-                    body.distance === 2);
-
-            if (!valid) {
-                context.report({
-                    node,
-                    messageId: "moveDeclToRoot",
-                    data: {
-                        type: (node.type === "FunctionDeclaration" ? "function" : "variable"),
-                        body: (body.type === "Program" ? "program" : "function body")
-                    }
-                });
+            const parent = node.parent;
+
+            if (
+                parent.type === "BlockStatement" && validBlockStatementParent.has(parent.parent.type)
+            ) {
+                return;
+            }
+
+            if (validParent.has(parent.type)) {
+                return;
             }
+
+            const upperFunction = astUtils.getUpperFunction(parent);
+
+            context.report({
+                node,
+                messageId: "moveDeclToRoot",
+                data: {
+                    type: (node.type === "FunctionDeclaration" ? "function" : "variable"),
+                    body: (upperFunction === null ? "program" : "function body")
+                }
+            });
         }
 
+
         return {
 
             FunctionDeclaration: check,

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

@@ -49,7 +49,7 @@ module.exports = {
         }
 
         /**
-         * Checks for any ocurrence of a BlockStatement in a place where lists of statements can appear
+         * Checks for any occurrence of a BlockStatement in a place where lists of statements can appear
          * @param {ASTNode} node The node to check
          * @returns {boolean} True if the node is a lone block.
          */

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

@@ -7,6 +7,9 @@
 
 const { isNumericLiteral } = require("./utils/ast-utils");
 
+// Maximum array length by the ECMAScript Specification.
+const MAX_ARRAY_LENGTH = 2 ** 32 - 1;
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -76,83 +79,115 @@ module.exports = {
             ignore = (config.ignore || []).map(normalizeIgnoreValue),
             ignoreArrayIndexes = !!config.ignoreArrayIndexes;
 
+        const okTypes = detectObjects ? [] : ["ObjectExpression", "Property", "AssignmentExpression"];
+
         /**
-         * Returns whether the number should be ignored
-         * @param {number} num the number
-         * @returns {boolean} true if the number should be ignored
+         * Returns whether the rule is configured to ignore the given value
+         * @param {bigint|number} value The value to check
+         * @returns {boolean} true if the value is ignored
          */
-        function shouldIgnoreNumber(num) {
-            return ignore.indexOf(num) !== -1;
+        function isIgnoredValue(value) {
+            return ignore.indexOf(value) !== -1;
         }
 
         /**
-         * 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
-         * @returns {boolean} true if the number should be ignored
+         * Returns whether the given node is used as a radix within parseInt() or Number.parseInt()
+         * @param {ASTNode} fullNumberNode `Literal` or `UnaryExpression` full number node
+         * @returns {boolean} true if the node is radix
          */
-        function shouldIgnoreParseInt(parent, node) {
-            return parent.type === "CallExpression" && node === parent.arguments[1] &&
-                (parent.callee.name === "parseInt" ||
-                parent.callee.type === "MemberExpression" &&
-                parent.callee.object.name === "Number" &&
-                parent.callee.property.name === "parseInt");
+        function isParseIntRadix(fullNumberNode) {
+            const parent = fullNumberNode.parent;
+
+            return parent.type === "CallExpression" && fullNumberNode === parent.arguments[1] &&
+                (
+                    parent.callee.name === "parseInt" ||
+                    (
+                        parent.callee.type === "MemberExpression" &&
+                        parent.callee.object.name === "Number" &&
+                        parent.callee.property.name === "parseInt"
+                    )
+                );
         }
 
         /**
-         * Returns whether the number should be ignored when used to define a JSX prop
-         * @param {ASTNode} parent the non-"UnaryExpression" parent
-         * @returns {boolean} true if the number should be ignored
+         * Returns whether the given node is a direct child of a JSX node.
+         * In particular, it aims to detect numbers used as prop values in JSX tags.
+         * Example: <input maxLength={10} />
+         * @param {ASTNode} fullNumberNode `Literal` or `UnaryExpression` full number node
+         * @returns {boolean} true if the node is a JSX number
          */
-        function shouldIgnoreJSXNumbers(parent) {
-            return parent.type.indexOf("JSX") === 0;
+        function isJSXNumber(fullNumberNode) {
+            return fullNumberNode.parent.type.indexOf("JSX") === 0;
         }
 
         /**
-         * Returns whether the number should be ignored when used as an array index with enabled 'ignoreArrayIndexes' option.
-         * @param {ASTNode} node Node to check
-         * @returns {boolean} true if the number should be ignored
+         * Returns whether the given node is used as an array index.
+         * Value must coerce to a valid array index name: "0", "1", "2" ... "4294967294".
+         *
+         * All other values, like "-1", "2.5", or "4294967295", are just "normal" object properties,
+         * which can be created and accessed on an array in addition to the array index properties,
+         * but they don't affect array's length and are not considered by methods such as .map(), .forEach() etc.
+         *
+         * The maximum array length by the specification is 2 ** 32 - 1 = 4294967295,
+         * thus the maximum valid index is 2 ** 32 - 2 = 4294967294.
+         *
+         * All notations are allowed, as long as the value coerces to one of "0", "1", "2" ... "4294967294".
+         *
+         * Valid examples:
+         * a[0], a[1], a[1.2e1], a[0xAB], a[0n], a[1n]
+         * a[-0] (same as a[0] because -0 coerces to "0")
+         * a[-0n] (-0n evaluates to 0n)
+         *
+         * Invalid examples:
+         * a[-1], a[-0xAB], a[-1n], a[2.5], a[1.23e1], a[12e-1]
+         * a[4294967295] (above the max index, it's an access to a regular property a["4294967295"])
+         * a[999999999999999999999] (even if it wasn't above the max index, it would be a["1e+21"])
+         * a[1e310] (same as a["Infinity"])
+         * @param {ASTNode} fullNumberNode `Literal` or `UnaryExpression` full number node
+         * @param {bigint|number} value Value expressed by the fullNumberNode
+         * @returns {boolean} true if the node is a valid array index
          */
-        function shouldIgnoreArrayIndexes(node) {
-            const parent = node.parent;
+        function isArrayIndex(fullNumberNode, value) {
+            const parent = fullNumberNode.parent;
 
-            return ignoreArrayIndexes &&
-                parent.type === "MemberExpression" && parent.property === node;
+            return parent.type === "MemberExpression" && parent.property === fullNumberNode &&
+                (Number.isInteger(value) || typeof value === "bigint") &&
+                value >= 0 && value < MAX_ARRAY_LENGTH;
         }
 
         return {
             Literal(node) {
-                const okTypes = detectObjects ? [] : ["ObjectExpression", "Property", "AssignmentExpression"];
-
                 if (!isNumericLiteral(node)) {
                     return;
                 }
 
                 let fullNumberNode;
-                let parent;
                 let value;
                 let raw;
 
-                // For negative magic numbers: update the value and parent node
+                // Treat unary minus as a part of the number
                 if (node.parent.type === "UnaryExpression" && node.parent.operator === "-") {
                     fullNumberNode = node.parent;
-                    parent = fullNumberNode.parent;
                     value = -node.value;
                     raw = `-${node.raw}`;
                 } else {
                     fullNumberNode = node;
-                    parent = node.parent;
                     value = node.value;
                     raw = node.raw;
                 }
 
-                if (shouldIgnoreNumber(value) ||
-                    shouldIgnoreParseInt(parent, fullNumberNode) ||
-                    shouldIgnoreArrayIndexes(fullNumberNode) ||
-                    shouldIgnoreJSXNumbers(parent)) {
+                // Always allow radix arguments and JSX props
+                if (
+                    isIgnoredValue(value) ||
+                    isParseIntRadix(fullNumberNode) ||
+                    isJSXNumber(fullNumberNode) ||
+                    (ignoreArrayIndexes && isArrayIndex(fullNumberNode, value))
+                ) {
                     return;
                 }
 
+                const parent = fullNumberNode.parent;
+
                 if (parent.type === "VariableDeclarator") {
                     if (enforceConst && parent.parent.kind !== "const") {
                         context.report({

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

@@ -11,6 +11,10 @@
 
 module.exports = {
     meta: {
+        deprecated: true,
+
+        replacedBy: ["node/no-mixed-requires"],
+
         type: "suggestion",
 
         docs: {

package/lib/rules/no-new-object.js

@@ -5,6 +5,12 @@
 
 "use strict";
 
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("./utils/ast-utils");
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -28,10 +34,17 @@ module.exports = {
     },
 
     create(context) {
-
         return {
-
             NewExpression(node) {
+                const variable = astUtils.getVariableByName(
+                    context.getScope(),
+                    node.callee.name
+                );
+
+                if (variable && variable.identifiers.length > 0) {
+                    return;
+                }
+
                 if (node.callee.name === "Object") {
                     context.report({
                         node,
@@ -40,6 +53,5 @@ module.exports = {
                 }
             }
         };
-
     }
 };

package/lib/rules/no-new-require.js

@@ -11,6 +11,10 @@
 
 module.exports = {
     meta: {
+        deprecated: true,
+
+        replacedBy: ["node/no-new-require"],
+
         type: "suggestion",
 
         docs: {

package/lib/rules/no-new-wrappers.js

@@ -32,7 +32,7 @@ module.exports = {
         return {
 
             NewExpression(node) {
-                const wrapperObjects = ["String", "Number", "Boolean", "Math", "JSON"];
+                const wrapperObjects = ["String", "Number", "Boolean"];
 
                 if (wrapperObjects.indexOf(node.callee.name) > -1) {
                     context.report({

package/lib/rules/no-obj-calls.js

@@ -9,7 +9,8 @@
 // Requirements
 //------------------------------------------------------------------------------
 
-const { CALL, ReferenceTracker } = require("eslint-utils");
+const { CALL, CONSTRUCT, ReferenceTracker } = require("eslint-utils");
+const getPropertyName = require("./utils/ast-utils").getStaticPropertyName;
 
 //------------------------------------------------------------------------------
 // Helpers
@@ -17,6 +18,18 @@ const { CALL, ReferenceTracker } = require("eslint-utils");
 
 const nonCallableGlobals = ["Atomics", "JSON", "Math", "Reflect"];
 
+/**
+ * Returns the name of the node to report
+ * @param {ASTNode} node A node to report
+ * @returns {string} name to report
+ */
+function getReportNodeName(node) {
+    if (node.callee.type === "MemberExpression") {
+        return getPropertyName(node.callee);
+    }
+    return node.callee.name;
+}
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -35,7 +48,8 @@ module.exports = {
         schema: [],
 
         messages: {
-            unexpectedCall: "'{{name}}' is not a function."
+            unexpectedCall: "'{{name}}' is not a function.",
+            unexpectedRefCall: "'{{name}}' is reference to '{{ref}}', which is not a function."
         }
     },
 
@@ -49,12 +63,17 @@ module.exports = {
 
                 for (const g of nonCallableGlobals) {
                     traceMap[g] = {
-                        [CALL]: true
+                        [CALL]: true,
+                        [CONSTRUCT]: true
                     };
                 }
 
-                for (const { node } of tracker.iterateGlobalReferences(traceMap)) {
-                    context.report({ node, messageId: "unexpectedCall", data: { name: node.callee.name } });
+                for (const { node, path } of tracker.iterateGlobalReferences(traceMap)) {
+                    const name = getReportNodeName(node);
+                    const ref = path[0];
+                    const messageId = name === ref ? "unexpectedCall" : "unexpectedRefCall";
+
+                    context.report({ node, messageId, data: { name, ref } });
                 }
             }
         };

package/lib/rules/no-path-concat.js

@@ -10,6 +10,10 @@
 
 module.exports = {
     meta: {
+        deprecated: true,
+
+        replacedBy: ["node/no-path-concat"],
+
         type: "suggestion",
 
         docs: {