eslint 7.0.0-alpha.2 → 7.1.0

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: [],
+
         type: "suggestion",
 
         docs: {

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

@@ -29,26 +29,29 @@ module.exports = {
 
     create(context) {
 
-        //--------------------------------------------------------------------------
-        // Helpers
-        //--------------------------------------------------------------------------
-
-        /**
-         * Reports a node.
-         * @param {ASTNode} node The node to report
-         * @returns {void}
-         * @private
-         */
-        function report(node) {
-            context.report({
-                node,
-                messageId: "noFunctionConstructor"
-            });
-        }
-
         return {
-            "NewExpression[callee.name = 'Function']": report,
-            "CallExpression[callee.name = 'Function']": report
+            "Program:exit"() {
+                const globalScope = context.getScope();
+                const variable = globalScope.set.get("Function");
+
+                if (variable && variable.defs.length === 0) {
+                    variable.references.forEach(ref => {
+                        const node = ref.identifier;
+                        const { parent } = node;
+
+                        if (
+                            parent &&
+                            (parent.type === "NewExpression" || parent.type === "CallExpression") &&
+                            node === parent.callee
+                        ) {
+                            context.report({
+                                node: parent,
+                                messageId: "noFunctionConstructor"
+                            });
+                        }
+                    });
+                }
+            }
         };
 
     }

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: [],
+
         type: "suggestion",
 
         docs: {

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

@@ -37,8 +37,9 @@ module.exports = {
                 if (variable && variable.defs.length === 0) {
                     variable.references.forEach(ref => {
                         const node = ref.identifier;
+                        const parent = node.parent;
 
-                        if (node.parent && node.parent.type === "NewExpression") {
+                        if (parent && parent.type === "NewExpression" && parent.callee === node) {
                             context.report({
                                 node,
                                 messageId: "noNewSymbol"

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: [],
+
         type: "suggestion",
 
         docs: {

package/lib/rules/no-plusplus.js

@@ -6,6 +6,41 @@
 
 "use strict";
 
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+/**
+ * Determines whether the given node is the update node of a `ForStatement`.
+ * @param {ASTNode} node The node to check.
+ * @returns {boolean} `true` if the node is `ForStatement` update.
+ */
+function isForStatementUpdate(node) {
+    const parent = node.parent;
+
+    return parent.type === "ForStatement" && parent.update === node;
+}
+
+/**
+ * Determines whether the given node is considered to be a for loop "afterthought" by the logic of this rule.
+ * In particular, it returns `true` if the given node is either:
+ *   - The update node of a `ForStatement`: for (;; i++) {}
+ *   - An operand of a sequence expression that is the update node: for (;; foo(), i++) {}
+ *   - An operand of a sequence expression that is child of another sequence expression, etc.,
+ *     up to the sequence expression that is the update node: for (;; foo(), (bar(), (baz(), i++))) {}
+ * @param {ASTNode} node The node to check.
+ * @returns {boolean} `true` if the node is a for loop afterthought.
+ */
+function isForLoopAfterthought(node) {
+    const parent = node.parent;
+
+    if (parent.type === "SequenceExpression") {
+        return isForLoopAfterthought(parent);
+    }
+
+    return isForStatementUpdate(node);
+}
+
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
@@ -42,18 +77,19 @@ module.exports = {
     create(context) {
 
         const config = context.options[0];
-        let allowInForAfterthought = false;
+        let allowForLoopAfterthoughts = false;
 
         if (typeof config === "object") {
-            allowInForAfterthought = config.allowForLoopAfterthoughts === true;
+            allowForLoopAfterthoughts = config.allowForLoopAfterthoughts === true;
         }
 
         return {
 
             UpdateExpression(node) {
-                if (allowInForAfterthought && node.parent.type === "ForStatement") {
+                if (allowForLoopAfterthoughts && isForLoopAfterthought(node)) {
                     return;
                 }
+
                 context.report({
                     node,
                     messageId: "unexpectedUnaryOp",

package/lib/rules/no-process-env.js

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

package/lib/rules/no-process-exit.js

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

package/lib/rules/no-prototype-builtins.js

@@ -47,7 +47,7 @@ module.exports = {
             if (DISALLOWED_PROPS.indexOf(propName) > -1) {
                 context.report({
                     messageId: "prototypeBuildIn",
-                    loc: node.callee.property.loc.start,
+                    loc: node.callee.property.loc,
                     data: { prop: propName },
                     node
                 });

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

@@ -40,6 +40,10 @@ const arrayOfStringsOrObjects = {
 
 module.exports = {
     meta: {
+        deprecated: true,
+
+        replacedBy: [],
+
         type: "suggestion",
 
         docs: {

package/lib/rules/no-sync.js

@@ -13,6 +13,10 @@
 
 module.exports = {
     meta: {
+        deprecated: true,
+
+        replacedBy: [],
+
         type: "suggestion",
 
         docs: {

package/lib/rules/no-unexpected-multiline.js

@@ -53,7 +53,11 @@ module.exports = {
             const nodeExpressionEnd = sourceCode.getTokenBefore(openParen);
 
             if (openParen.loc.start.line !== nodeExpressionEnd.loc.end.line) {
-                context.report({ node, loc: openParen.loc.start, messageId, data: { char: openParen.value } });
+                context.report({
+                    node,
+                    loc: openParen.loc,
+                    messageId
+                });
             }
         }
 
@@ -71,18 +75,24 @@ module.exports = {
             },
 
             TaggedTemplateExpression(node) {
-                if (node.tag.loc.end.line === node.quasi.loc.start.line) {
-                    return;
-                }
-
-                // handle generics type parameters on template tags
-                const tokenBefore = sourceCode.getTokenBefore(node.quasi);
-
-                if (tokenBefore.loc.end.line === node.quasi.loc.start.line) {
-                    return;
+                const { quasi } = node;
+
+                // handles common tags, parenthesized tags, and typescript's generic type arguments
+                const tokenBefore = sourceCode.getTokenBefore(quasi);
+
+                if (tokenBefore.loc.end.line !== quasi.loc.start.line) {
+                    context.report({
+                        node,
+                        loc: {
+                            start: quasi.loc.start,
+                            end: {
+                                line: quasi.loc.start.line,
+                                column: quasi.loc.start.column + 1
+                            }
+                        },
+                        messageId: "taggedTemplate"
+                    });
                 }
-
-                context.report({ node, loc: node.loc.start, messageId: "taggedTemplate" });
             },
 
             CallExpression(node) {

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

@@ -105,7 +105,7 @@ module.exports = {
 
                     context.report({
                         node,
-                        loc: operatorToken.loc.start,
+                        loc: operatorToken.loc,
                         messageId: "unexpectedConcat"
                     });
                 }

package/lib/rules/one-var-declaration-per-line.js

@@ -71,7 +71,7 @@ module.exports = {
                         context.report({
                             node,
                             messageId: "expectVarOnNewline",
-                            loc: current.loc.start,
+                            loc: current.loc,
                             fix: fixer => fixer.insertTextBefore(current, "\n")
                         });
                     }

package/lib/rules/operator-assignment.js

@@ -214,12 +214,12 @@ module.exports = {
                             ) {
                                 rightText = `${sourceCode.text.slice(operatorToken.range[1], node.right.range[0])}(${sourceCode.getText(node.right)})`;
                             } else {
-                                const firstRightToken = sourceCode.getFirstToken(node.right);
+                                const tokenAfterOperator = sourceCode.getTokenAfter(operatorToken, { includeComments: true });
                                 let rightTextPrefix = "";
 
                                 if (
-                                    operatorToken.range[1] === firstRightToken.range[0] &&
-                                    !astUtils.canTokensBeAdjacent({ type: "Punctuator", value: newOperator }, firstRightToken)
+                                    operatorToken.range[1] === tokenAfterOperator.range[0] &&
+                                    !astUtils.canTokensBeAdjacent({ type: "Punctuator", value: newOperator }, tokenAfterOperator)
                                 ) {
                                     rightTextPrefix = " "; // foo+=+bar -> foo= foo+ +bar
                                 }

package/lib/rules/operator-linebreak.js

@@ -172,10 +172,7 @@ module.exports = {
                 // lone operator
                 context.report({
                     node,
-                    loc: {
-                        line: operatorToken.loc.end.line,
-                        column: operatorToken.loc.end.column
-                    },
+                    loc: operatorToken.loc,
                     messageId: "badLinebreak",
                     data: {
                         operator
@@ -187,10 +184,7 @@ module.exports = {
 
                 context.report({
                     node,
-                    loc: {
-                        line: operatorToken.loc.end.line,
-                        column: operatorToken.loc.end.column
-                    },
+                    loc: operatorToken.loc,
                     messageId: "operatorAtBeginning",
                     data: {
                         operator
@@ -202,10 +196,7 @@ module.exports = {
 
                 context.report({
                     node,
-                    loc: {
-                        line: operatorToken.loc.end.line,
-                        column: operatorToken.loc.end.column
-                    },
+                    loc: operatorToken.loc,
                     messageId: "operatorAtEnd",
                     data: {
                         operator
@@ -217,10 +208,7 @@ module.exports = {
 
                 context.report({
                     node,
-                    loc: {
-                        line: operatorToken.loc.end.line,
-                        column: operatorToken.loc.end.column
-                    },
+                    loc: operatorToken.loc,
                     messageId: "noLinebreak",
                     data: {
                         operator