eslint 7.4.0 → 7.5.0

package/lib/rules/func-call-spacing.js

@@ -126,15 +126,24 @@ module.exports = {
                     messageId: "unexpectedWhitespace",
                     fix(fixer) {
 
+                        // Don't remove comments.
+                        if (sourceCode.commentsExistBetween(leftToken, rightToken)) {
+                            return null;
+                        }
+
+                        // If `?.` exsits, it doesn't hide no-undexpected-multiline errors
+                        if (node.optional) {
+                            return fixer.replaceTextRange([leftToken.range[1], rightToken.range[0]], "?.");
+                        }
+
                         /*
                          * Only autofix if there is no newline
                          * https://github.com/eslint/eslint/issues/7787
                          */
-                        if (!hasNewline) {
-                            return fixer.removeRange([leftToken.range[1], rightToken.range[0]]);
+                        if (hasNewline) {
+                            return null;
                         }
-
-                        return null;
+                        return fixer.removeRange([leftToken.range[1], rightToken.range[0]]);
                     }
                 });
             } else if (!never && !hasWhitespace) {
@@ -149,6 +158,9 @@ module.exports = {
                     },
                     messageId: "missing",
                     fix(fixer) {
+                        if (node.optional) {
+                            return null; // Not sure if inserting a space to either before/after `?.` token.
+                        }
                         return fixer.insertTextBefore(rightToken, " ");
                     }
                 });
@@ -161,7 +173,31 @@ module.exports = {
                     },
                     messageId: "unexpectedNewline",
                     fix(fixer) {
-                        return fixer.replaceTextRange([leftToken.range[1], rightToken.range[0]], " ");
+
+                        /*
+                         * Only autofix if there is no newline
+                         * https://github.com/eslint/eslint/issues/7787
+                         * But if `?.` exsits, it doesn't hide no-undexpected-multiline errors
+                         */
+                        if (!node.optional) {
+                            return null;
+                        }
+
+                        // Don't remove comments.
+                        if (sourceCode.commentsExistBetween(leftToken, rightToken)) {
+                            return null;
+                        }
+
+                        const range = [leftToken.range[1], rightToken.range[0]];
+                        const qdToken = sourceCode.getTokenAfter(leftToken);
+
+                        if (qdToken.range[0] === leftToken.range[1]) {
+                            return fixer.replaceTextRange(range, "?. ");
+                        }
+                        if (qdToken.range[1] === rightToken.range[0]) {
+                            return fixer.replaceTextRange(range, " ?.");
+                        }
+                        return fixer.replaceTextRange(range, " ?. ");
                     }
                 });
             }
@@ -172,7 +208,7 @@ module.exports = {
                 const lastToken = sourceCode.getLastToken(node);
                 const lastCalleeToken = sourceCode.getLastToken(node.callee);
                 const parenToken = sourceCode.getFirstTokenBetween(lastCalleeToken, lastToken, astUtils.isOpeningParenToken);
-                const prevToken = parenToken && sourceCode.getTokenBefore(parenToken);
+                const prevToken = parenToken && sourceCode.getTokenBefore(parenToken, astUtils.isNotQuestionDotToken);
 
                 // Parens in NewExpression are optional
                 if (!(parenToken && parenToken.range[1] < node.range[1])) {

package/lib/rules/func-name-matching.js

@@ -117,10 +117,7 @@ module.exports = {
             if (!node) {
                 return false;
             }
-            return node.type === "CallExpression" &&
-                node.callee.type === "MemberExpression" &&
-                node.callee.object.name === objName &&
-                node.callee.property.name === funcName;
+            return node.type === "CallExpression" && astUtils.isSpecificMemberAccess(node.callee, objName, funcName);
         }
 
         /**

package/lib/rules/global-require.js

@@ -13,7 +13,8 @@ const ACCEPTABLE_PARENTS = [
     "CallExpression",
     "ConditionalExpression",
     "Program",
-    "VariableDeclaration"
+    "VariableDeclaration",
+    "ChainExpression"
 ];
 
 /**

package/lib/rules/id-blacklist.js

@@ -0,0 +1,233 @@
+/**
+ * @fileoverview Rule that warns when identifier names that are
+ * specified in the configuration are used.
+ * @author Keith Cirkel (http://keithcirkel.co.uk)
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+/**
+ * Checks whether the given node represents assignment target in a normal assignment or destructuring.
+ * @param {ASTNode} node The node to check.
+ * @returns {boolean} `true` if the node is assignment target.
+ */
+function isAssignmentTarget(node) {
+    const parent = node.parent;
+
+    return (
+
+        // normal assignment
+        (
+            parent.type === "AssignmentExpression" &&
+            parent.left === node
+        ) ||
+
+        // destructuring
+        parent.type === "ArrayPattern" ||
+        parent.type === "RestElement" ||
+        (
+            parent.type === "Property" &&
+            parent.value === node &&
+            parent.parent.type === "ObjectPattern"
+        ) ||
+        (
+            parent.type === "AssignmentPattern" &&
+            parent.left === node
+        )
+    );
+}
+
+/**
+ * Checks whether the given node represents an imported name that is renamed in the same import/export specifier.
+ *
+ * Examples:
+ * import { a as b } from 'mod'; // node `a` is renamed import
+ * export { a as b } from 'mod'; // node `a` is renamed import
+ * @param {ASTNode} node `Identifier` node to check.
+ * @returns {boolean} `true` if the node is a renamed import.
+ */
+function isRenamedImport(node) {
+    const parent = node.parent;
+
+    return (
+        (
+            parent.type === "ImportSpecifier" &&
+            parent.imported !== parent.local &&
+            parent.imported === node
+        ) ||
+        (
+            parent.type === "ExportSpecifier" &&
+            parent.parent.source && // re-export
+            parent.local !== parent.exported &&
+            parent.local === node
+        )
+    );
+}
+
+/**
+ * Checks whether the given node is a renamed identifier node in an ObjectPattern destructuring.
+ *
+ * Examples:
+ * const { a : b } = foo; // node `a` is renamed node.
+ * @param {ASTNode} node `Identifier` node to check.
+ * @returns {boolean} `true` if the node is a renamed node in an ObjectPattern destructuring.
+ */
+function isRenamedInDestructuring(node) {
+    const parent = node.parent;
+
+    return (
+        (
+            !parent.computed &&
+            parent.type === "Property" &&
+            parent.parent.type === "ObjectPattern" &&
+            parent.value !== node &&
+            parent.key === node
+        )
+    );
+}
+
+/**
+ * Checks whether the given node represents shorthand definition of a property in an object literal.
+ * @param {ASTNode} node `Identifier` node to check.
+ * @returns {boolean} `true` if the node is a shorthand property definition.
+ */
+function isShorthandPropertyDefinition(node) {
+    const parent = node.parent;
+
+    return (
+        parent.type === "Property" &&
+        parent.parent.type === "ObjectExpression" &&
+        parent.shorthand
+    );
+}
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+module.exports = {
+    meta: {
+        deprecated: true,
+        replacedBy: ["id-denylist"],
+
+        type: "suggestion",
+
+        docs: {
+            description: "disallow specified identifiers",
+            category: "Stylistic Issues",
+            recommended: false,
+            url: "https://eslint.org/docs/rules/id-blacklist"
+        },
+
+        schema: {
+            type: "array",
+            items: {
+                type: "string"
+            },
+            uniqueItems: true
+        },
+        messages: {
+            restricted: "Identifier '{{name}}' is restricted."
+        }
+    },
+
+    create(context) {
+
+        const denyList = new Set(context.options);
+        const reportedNodes = new Set();
+
+        let globalScope;
+
+        /**
+         * Checks whether the given name is restricted.
+         * @param {string} name The name to check.
+         * @returns {boolean} `true` if the name is restricted.
+         * @private
+         */
+        function isRestricted(name) {
+            return denyList.has(name);
+        }
+
+        /**
+         * Checks whether the given node represents a reference to a global variable that is not declared in the source code.
+         * These identifiers will be allowed, as it is assumed that user has no control over the names of external global variables.
+         * @param {ASTNode} node `Identifier` node to check.
+         * @returns {boolean} `true` if the node is a reference to a global variable.
+         */
+        function isReferenceToGlobalVariable(node) {
+            const variable = globalScope.set.get(node.name);
+
+            return variable && variable.defs.length === 0 &&
+                variable.references.some(ref => ref.identifier === node);
+        }
+
+        /**
+         * Determines whether the given node should be checked.
+         * @param {ASTNode} node `Identifier` node.
+         * @returns {boolean} `true` if the node should be checked.
+         */
+        function shouldCheck(node) {
+            const parent = node.parent;
+
+            /*
+             * Member access has special rules for checking property names.
+             * Read access to a property with a restricted name is allowed, because it can be on an object that user has no control over.
+             * Write access isn't allowed, because it potentially creates a new property with a restricted name.
+             */
+            if (
+                parent.type === "MemberExpression" &&
+                parent.property === node &&
+                !parent.computed
+            ) {
+                return isAssignmentTarget(parent);
+            }
+
+            return (
+                parent.type !== "CallExpression" &&
+                parent.type !== "NewExpression" &&
+                !isRenamedImport(node) &&
+                !isRenamedInDestructuring(node) &&
+                !(
+                    isReferenceToGlobalVariable(node) &&
+                    !isShorthandPropertyDefinition(node)
+                )
+            );
+        }
+
+        /**
+         * Reports an AST node as a rule violation.
+         * @param {ASTNode} node The node to report.
+         * @returns {void}
+         * @private
+         */
+        function report(node) {
+            if (!reportedNodes.has(node)) {
+                context.report({
+                    node,
+                    messageId: "restricted",
+                    data: {
+                        name: node.name
+                    }
+                });
+                reportedNodes.add(node);
+            }
+        }
+
+        return {
+
+            Program() {
+                globalScope = context.getScope();
+            },
+
+            Identifier(node) {
+                if (isRestricted(node.name) && shouldCheck(node)) {
+                    report(node);
+                }
+            }
+        };
+    }
+};

package/lib/rules/indent.js

@@ -32,6 +32,7 @@ const KNOWN_NODES = new Set([
     "BreakStatement",
     "CallExpression",
     "CatchClause",
+    "ChainExpression",
     "ClassBody",
     "ClassDeclaration",
     "ClassExpression",
@@ -934,6 +935,24 @@ module.exports = {
             parameterParens.add(openingParen);
             parameterParens.add(closingParen);
 
+            /*
+             * If `?.` token exists, set desired offset for that.
+             * This logic is copied from `MemberExpression`'s.
+             */
+            if (node.optional) {
+                const dotToken = sourceCode.getTokenAfter(node.callee, astUtils.isQuestionDotToken);
+                const calleeParenCount = sourceCode.getTokensBetween(node.callee, dotToken, { filter: astUtils.isClosingParenToken }).length;
+                const firstTokenOfCallee = calleeParenCount
+                    ? sourceCode.getTokenBefore(node.callee, { skip: calleeParenCount - 1 })
+                    : sourceCode.getFirstToken(node.callee);
+                const lastTokenOfCallee = sourceCode.getTokenBefore(dotToken);
+                const offsetBase = lastTokenOfCallee.loc.end.line === openingParen.loc.start.line
+                    ? lastTokenOfCallee
+                    : firstTokenOfCallee;
+
+                offsets.setDesiredOffset(dotToken, offsetBase, 1);
+            }
+
             const offsetAfterToken = node.callee.type === "TaggedTemplateExpression" ? sourceCode.getFirstToken(node.callee.quasi) : openingParen;
             const offsetToken = sourceCode.getTokenBefore(offsetAfterToken);
 

package/lib/rules/index.js

@@ -56,9 +56,7 @@ module.exports = new LazyLoadingRuleMap(Object.entries({
     "grouped-accessor-pairs": () => require("./grouped-accessor-pairs"),
     "guard-for-in": () => require("./guard-for-in"),
     "handle-callback-err": () => require("./handle-callback-err"),
-
-    // Renamed to id-denylist.
-    "id-blacklist": () => require("./id-denylist"),
+    "id-blacklist": () => require("./id-blacklist"),
     "id-denylist": () => require("./id-denylist"),
     "id-length": () => require("./id-length"),
     "id-match": () => require("./id-match"),

package/lib/rules/keyword-spacing.js

@@ -126,7 +126,7 @@ module.exports = {
                 !sourceCode.isSpaceBetweenTokens(prevToken, token)
             ) {
                 context.report({
-                    loc: token.loc.start,
+                    loc: token.loc,
                     messageId: "expectedBefore",
                     data: token,
                     fix(fixer) {
@@ -178,7 +178,7 @@ module.exports = {
                 !sourceCode.isSpaceBetweenTokens(token, nextToken)
             ) {
                 context.report({
-                    loc: token.loc.start,
+                    loc: token.loc,
                     messageId: "expectedAfter",
                     data: token,
                     fix(fixer) {

package/lib/rules/max-len.js

@@ -383,11 +383,22 @@ module.exports = {
                     return;
                 }
 
+                const loc = {
+                    start: {
+                        line: lineNumber,
+                        column: 0
+                    },
+                    end: {
+                        line: lineNumber,
+                        column: textToMeasure.length
+                    }
+                };
+
                 if (commentLengthApplies) {
                     if (lineLength > maxCommentLength) {
                         context.report({
                             node,
-                            loc: { line: lineNumber, column: 0 },
+                            loc,
                             messageId: "maxComment",
                             data: {
                                 lineLength,
@@ -398,7 +409,7 @@ module.exports = {
                 } else if (lineLength > maxLength) {
                     context.report({
                         node,
-                        loc: { line: lineNumber, column: 0 },
+                        loc,
                         messageId: "max",
                         data: {
                             lineLength,

package/lib/rules/new-cap.js

@@ -158,15 +158,9 @@ module.exports = {
          * @returns {string} name
          */
         function extractNameFromExpression(node) {
-
-            let name = "";
-
-            if (node.callee.type === "MemberExpression") {
-                name = astUtils.getStaticPropertyName(node.callee) || "";
-            } else {
-                name = node.callee.name;
-            }
-            return name;
+            return node.callee.type === "Identifier"
+                ? node.callee.name
+                : astUtils.getStaticPropertyName(node.callee) || "";
         }
 
         /**
@@ -212,14 +206,16 @@ module.exports = {
                 return true;
             }
 
-            if (calleeName === "UTC" && node.callee.type === "MemberExpression") {
+            const callee = astUtils.skipChainExpression(node.callee);
+
+            if (calleeName === "UTC" && callee.type === "MemberExpression") {
 
                 // allow if callee is Date.UTC
-                return node.callee.object.type === "Identifier" &&
-                    node.callee.object.name === "Date";
+                return callee.object.type === "Identifier" &&
+                    callee.object.name === "Date";
             }
 
-            return skipProperties && node.callee.type === "MemberExpression";
+            return skipProperties && callee.type === "MemberExpression";
         }
 
         /**
@@ -229,7 +225,7 @@ module.exports = {
          * @returns {void}
          */
         function report(node, messageId) {
-            let callee = node.callee;
+            let callee = astUtils.skipChainExpression(node.callee);
 
             if (callee.type === "MemberExpression") {
                 callee = callee.property;

package/lib/rules/newline-per-chained-call.js

@@ -57,7 +57,16 @@ module.exports = {
          * @returns {string} The prefix of the node.
          */
         function getPrefix(node) {
-            return node.computed ? "[" : ".";
+            if (node.computed) {
+                if (node.optional) {
+                    return "?.[";
+                }
+                return "[";
+            }
+            if (node.optional) {
+                return "?.";
+            }
+            return ".";
         }
 
         /**
@@ -76,17 +85,18 @@ module.exports = {
 
         return {
             "CallExpression:exit"(node) {
-                if (!node.callee || node.callee.type !== "MemberExpression") {
+                const callee = astUtils.skipChainExpression(node.callee);
+
+                if (callee.type !== "MemberExpression") {
                     return;
                 }
 
-                const callee = node.callee;
-                let parent = callee.object;
+                let parent = astUtils.skipChainExpression(callee.object);
                 let depth = 1;
 
                 while (parent && parent.callee) {
                     depth += 1;
-                    parent = parent.callee.object;
+                    parent = astUtils.skipChainExpression(astUtils.skipChainExpression(parent.callee).object);
                 }
 
                 if (depth > ignoreChainWithDepth && astUtils.isTokenOnSameLine(callee.object, callee.property)) {

package/lib/rules/no-alert.js

@@ -10,7 +10,8 @@
 
 const {
     getStaticPropertyName: getPropertyName,
-    getVariableByName
+    getVariableByName,
+    skipChainExpression
 } = require("./utils/ast-utils");
 
 //------------------------------------------------------------------------------
@@ -64,7 +65,13 @@ function isGlobalThisReferenceOrGlobalWindow(scope, node) {
     if (scope.type === "global" && node.type === "ThisExpression") {
         return true;
     }
-    if (node.name === "window" || (node.name === "globalThis" && getVariableByName(scope, "globalThis"))) {
+    if (
+        node.type === "Identifier" &&
+        (
+            node.name === "window" ||
+            (node.name === "globalThis" && getVariableByName(scope, "globalThis"))
+        )
+    ) {
         return !isShadowed(scope, node);
     }
 
@@ -96,7 +103,7 @@ module.exports = {
     create(context) {
         return {
             CallExpression(node) {
-                const callee = node.callee,
+                const callee = skipChainExpression(node.callee),
                     currentScope = context.getScope();
 
                 // without window.

package/lib/rules/no-eval.js

@@ -21,38 +21,6 @@ const candidatesOfGlobalObject = Object.freeze([
     "globalThis"
 ]);
 
-/**
- * Checks a given node is a Identifier node of the specified name.
- * @param {ASTNode} node A node to check.
- * @param {string} name A name to check.
- * @returns {boolean} `true` if the node is a Identifier node of the name.
- */
-function isIdentifier(node, name) {
-    return node.type === "Identifier" && node.name === name;
-}
-
-/**
- * Checks a given node is a Literal node of the specified string value.
- * @param {ASTNode} node A node to check.
- * @param {string} name A name to check.
- * @returns {boolean} `true` if the node is a Literal node of the name.
- */
-function isConstant(node, name) {
-    switch (node.type) {
-        case "Literal":
-            return node.value === name;
-
-        case "TemplateLiteral":
-            return (
-                node.expressions.length === 0 &&
-                node.quasis[0].value.cooked === name
-            );
-
-        default:
-            return false;
-    }
-}
-
 /**
  * Checks a given node is a MemberExpression node which has the specified name's
  * property.
@@ -62,10 +30,7 @@ function isConstant(node, name) {
  *      the specified name's property
  */
 function isMember(node, name) {
-    return (
-        node.type === "MemberExpression" &&
-        (node.computed ? isConstant : isIdentifier)(node.property, name)
-    );
+    return astUtils.isSpecificMemberAccess(node, null, name);
 }
 
 //------------------------------------------------------------------------------
@@ -230,7 +195,12 @@ module.exports = {
                 "CallExpression:exit"(node) {
                     const callee = node.callee;
 
-                    if (isIdentifier(callee, "eval")) {
+                    /*
+                     * Optional call (`eval?.("code")`) is not direct eval.
+                     * The direct eval is only step 6.a.vi of https://tc39.es/ecma262/#sec-function-calls-runtime-semantics-evaluation
+                     * But the optional call is https://tc39.es/ecma262/#sec-optional-chaining-chain-evaluation
+                     */
+                    if (!node.optional && astUtils.isSpecificId(callee, "eval")) {
                         report(callee);
                     }
                 }
@@ -241,7 +211,7 @@ module.exports = {
             "CallExpression:exit"(node) {
                 const callee = node.callee;
 
-                if (isIdentifier(callee, "eval")) {
+                if (astUtils.isSpecificId(callee, "eval")) {
                     report(callee);
                 }
             },