eslint 8.11.0 → 8.14.0

package/lib/rules/no-constant-condition.js

@@ -5,6 +5,8 @@
 
 "use strict";
 
+const { isConstant } = require("./utils/ast-utils");
+
 //------------------------------------------------------------------------------
 // Helpers
 //------------------------------------------------------------------------------
@@ -53,201 +55,6 @@ module.exports = {
         // Helpers
         //--------------------------------------------------------------------------
 
-        /**
-         * Returns literal's value converted to the Boolean type
-         * @param {ASTNode} node any `Literal` node
-         * @returns {boolean | null} `true` when node is truthy, `false` when node is falsy,
-         *  `null` when it cannot be determined.
-         */
-        function getBooleanValue(node) {
-            if (node.value === null) {
-
-                /*
-                 * it might be a null literal or bigint/regex literal in unsupported environments .
-                 * https://github.com/estree/estree/blob/14df8a024956ea289bd55b9c2226a1d5b8a473ee/es5.md#regexpliteral
-                 * https://github.com/estree/estree/blob/14df8a024956ea289bd55b9c2226a1d5b8a473ee/es2020.md#bigintliteral
-                 */
-
-                if (node.raw === "null") {
-                    return false;
-                }
-
-                // regex is always truthy
-                if (typeof node.regex === "object") {
-                    return true;
-                }
-
-                return null;
-            }
-
-            return !!node.value;
-        }
-
-        /**
-         * Checks if a branch node of LogicalExpression short circuits the whole condition
-         * @param {ASTNode} node The branch of main condition which needs to be checked
-         * @param {string} operator The operator of the main LogicalExpression.
-         * @returns {boolean} true when condition short circuits whole condition
-         */
-        function isLogicalIdentity(node, operator) {
-            switch (node.type) {
-                case "Literal":
-                    return (operator === "||" && getBooleanValue(node) === true) ||
-                           (operator === "&&" && getBooleanValue(node) === false);
-
-                case "UnaryExpression":
-                    return (operator === "&&" && node.operator === "void");
-
-                case "LogicalExpression":
-
-                    /*
-                     * handles `a && false || b`
-                     * `false` is an identity element of `&&` but not `||`
-                     */
-                    return operator === node.operator &&
-                             (
-                                 isLogicalIdentity(node.left, operator) ||
-                                 isLogicalIdentity(node.right, operator)
-                             );
-
-                case "AssignmentExpression":
-                    return ["||=", "&&="].includes(node.operator) &&
-                        operator === node.operator.slice(0, -1) &&
-                        isLogicalIdentity(node.right, operator);
-
-                // no default
-            }
-            return false;
-        }
-
-        /**
-         * Checks if an identifier is a reference to a global variable.
-         * @param {ASTNode} node An identifier node to check.
-         * @returns {boolean} `true` if the identifier is a reference to a global variable.
-         */
-        function isReferenceToGlobalVariable(node) {
-            const scope = context.getScope();
-            const reference = scope.references.find(ref => ref.identifier === node);
-
-            return Boolean(
-                reference &&
-                reference.resolved &&
-                reference.resolved.scope.type === "global" &&
-                reference.resolved.defs.length === 0
-            );
-        }
-
-        /**
-         * Checks if a node has a constant truthiness value.
-         * @param {ASTNode} node The AST node to check.
-         * @param {boolean} inBooleanPosition `true` if checking the test of a
-         * condition. `false` in all other cases. When `false`, checks if -- for
-         * both string and number -- if coerced to that type, the value will
-         * be constant.
-         * @returns {Bool} true when node's truthiness is constant
-         * @private
-         */
-        function isConstant(node, inBooleanPosition) {
-
-            // node.elements can return null values in the case of sparse arrays ex. [,]
-            if (!node) {
-                return true;
-            }
-            switch (node.type) {
-                case "Literal":
-                case "ArrowFunctionExpression":
-                case "FunctionExpression":
-                    return true;
-                case "ClassExpression":
-                case "ObjectExpression":
-
-                    /**
-                     * In theory objects like:
-                     *
-                     * `{toString: () => a}`
-                     * `{valueOf: () => a}`
-                     *
-                     * Or a classes like:
-                     *
-                     * `class { static toString() { return a } }`
-                     * `class { static valueOf() { return a } }`
-                     *
-                     * Are not constant verifiably when `inBooleanPosition` is
-                     * false, but it's an edge case we've opted not to handle.
-                     */
-                    return true;
-                case "TemplateLiteral":
-                    return (inBooleanPosition && node.quasis.some(quasi => quasi.value.cooked.length)) ||
-                        node.expressions.every(exp => isConstant(exp, false));
-
-                case "ArrayExpression": {
-                    if (!inBooleanPosition) {
-                        return node.elements.every(element => isConstant(element, false));
-                    }
-                    return true;
-                }
-
-                case "UnaryExpression":
-                    if (
-                        node.operator === "void" ||
-                        node.operator === "typeof" && inBooleanPosition
-                    ) {
-                        return true;
-                    }
-
-                    if (node.operator === "!") {
-                        return isConstant(node.argument, true);
-                    }
-
-                    return isConstant(node.argument, false);
-
-                case "BinaryExpression":
-                    return isConstant(node.left, false) &&
-                            isConstant(node.right, false) &&
-                            node.operator !== "in";
-
-                case "LogicalExpression": {
-                    const isLeftConstant = isConstant(node.left, inBooleanPosition);
-                    const isRightConstant = isConstant(node.right, inBooleanPosition);
-                    const isLeftShortCircuit = (isLeftConstant && isLogicalIdentity(node.left, node.operator));
-                    const isRightShortCircuit = (inBooleanPosition && isRightConstant && isLogicalIdentity(node.right, node.operator));
-
-                    return (isLeftConstant && isRightConstant) ||
-                        isLeftShortCircuit ||
-                        isRightShortCircuit;
-                }
-                case "NewExpression":
-                    return inBooleanPosition;
-                case "AssignmentExpression":
-                    if (node.operator === "=") {
-                        return isConstant(node.right, inBooleanPosition);
-                    }
-
-                    if (["||=", "&&="].includes(node.operator) && inBooleanPosition) {
-                        return isLogicalIdentity(node.right, node.operator.slice(0, -1));
-                    }
-
-                    return false;
-
-                case "SequenceExpression":
-                    return isConstant(node.expressions[node.expressions.length - 1], inBooleanPosition);
-                case "SpreadElement":
-                    return isConstant(node.argument, inBooleanPosition);
-                case "CallExpression":
-                    if (node.callee.type === "Identifier" && node.callee.name === "Boolean") {
-                        if (node.arguments.length === 0 || isConstant(node.arguments[0], true)) {
-                            return isReferenceToGlobalVariable(node.callee);
-                        }
-                    }
-                    return false;
-                case "Identifier":
-                    return node.name === "undefined" && isReferenceToGlobalVariable(node);
-
-                // no default
-            }
-            return false;
-        }
-
         /**
          * Tracks when the given node contains a constant condition.
          * @param {ASTNode} node The AST node to check.
@@ -255,7 +62,7 @@ module.exports = {
          * @private
          */
         function trackConstantConditionLoop(node) {
-            if (node.test && isConstant(node.test, true)) {
+            if (node.test && isConstant(context.getScope(), node.test, true)) {
                 loopsInCurrentScope.add(node);
             }
         }
@@ -280,7 +87,7 @@ module.exports = {
          * @private
          */
         function reportIfConstant(node) {
-            if (node.test && isConstant(node.test, true)) {
+            if (node.test && isConstant(context.getScope(), node.test, true)) {
                 context.report({ node: node.test, messageId: "unexpected" });
             }
         }

package/lib/rules/no-eval.js

@@ -72,21 +72,25 @@ module.exports = {
         let funcInfo = null;
 
         /**
-         * Pushs a variable scope (Program or Function) information to the stack.
+         * Pushs a `this` scope (non-arrow function, class static block, or class field initializer) information to the stack.
+         * Top-level scopes are handled separately.
          *
          * This is used in order to check whether or not `this` binding is a
          * reference to the global object.
-         * @param {ASTNode} node A node of the scope. This is one of Program,
-         *      FunctionDeclaration, FunctionExpression, and ArrowFunctionExpression.
+         * @param {ASTNode} node A node of the scope.
+         *      For functions, this is one of FunctionDeclaration, FunctionExpression.
+         *      For class static blocks, this is StaticBlock.
+         *      For class field initializers, this can be any node that is PropertyDefinition#value.
          * @returns {void}
          */
-        function enterVarScope(node) {
+        function enterThisScope(node) {
             const strict = context.getScope().isStrict;
 
             funcInfo = {
                 upper: funcInfo,
                 node,
                 strict,
+                isTopLevelOfScript: false,
                 defaultThis: false,
                 initialized: strict
             };
@@ -96,7 +100,7 @@ module.exports = {
          * Pops a variable scope from the stack.
          * @returns {void}
          */
-        function exitVarScope() {
+        function exitThisScope() {
             funcInfo = funcInfo.upper;
         }
 
@@ -222,12 +226,14 @@ module.exports = {
                     strict =
                         scope.isStrict ||
                         node.sourceType === "module" ||
-                        (features.globalReturn && scope.childScopes[0].isStrict);
+                        (features.globalReturn && scope.childScopes[0].isStrict),
+                    isTopLevelOfScript = node.sourceType !== "module" && !features.globalReturn;
 
                 funcInfo = {
                     upper: null,
                     node,
                     strict,
+                    isTopLevelOfScript,
                     defaultThis: true,
                     initialized: true
                 };
@@ -236,21 +242,19 @@ module.exports = {
             "Program:exit"() {
                 const globalScope = context.getScope();
 
-                exitVarScope();
+                exitThisScope();
                 reportAccessingEval(globalScope);
                 reportAccessingEvalViaGlobalObject(globalScope);
             },
 
-            FunctionDeclaration: enterVarScope,
-            "FunctionDeclaration:exit": exitVarScope,
-            FunctionExpression: enterVarScope,
-            "FunctionExpression:exit": exitVarScope,
-            ArrowFunctionExpression: enterVarScope,
-            "ArrowFunctionExpression:exit": exitVarScope,
-            "PropertyDefinition > *.value": enterVarScope,
-            "PropertyDefinition > *.value:exit": exitVarScope,
-            StaticBlock: enterVarScope,
-            "StaticBlock:exit": exitVarScope,
+            FunctionDeclaration: enterThisScope,
+            "FunctionDeclaration:exit": exitThisScope,
+            FunctionExpression: enterThisScope,
+            "FunctionExpression:exit": exitThisScope,
+            "PropertyDefinition > *.value": enterThisScope,
+            "PropertyDefinition > *.value:exit": exitThisScope,
+            StaticBlock: enterThisScope,
+            "StaticBlock:exit": exitThisScope,
 
             ThisExpression(node) {
                 if (!isMember(node.parent, "eval")) {
@@ -269,7 +273,8 @@ module.exports = {
                     );
                 }
 
-                if (!funcInfo.strict && funcInfo.defaultThis) {
+                // `this` at the top level of scripts always refers to the global object
+                if (funcInfo.isTopLevelOfScript || (!funcInfo.strict && funcInfo.defaultThis)) {
 
                     // `this.eval` is possible built-in `eval`.
                     report(node.parent);

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

@@ -1,5 +1,5 @@
 /**
- * @fileoverview A rule to disallow `this` keywords outside of classes or class-like objects.
+ * @fileoverview A rule to disallow `this` keywords in contexts where the value of `this` is `undefined`.
  * @author Toru Nagashima
  */
 
@@ -36,7 +36,7 @@ module.exports = {
         type: "suggestion",
 
         docs: {
-            description: "disallow `this` keywords outside of classes or class-like objects",
+            description: "disallow use of `this` in contexts where the value of `this` is `undefined`",
             recommended: false,
             url: "https://eslint.org/docs/rules/no-invalid-this"
         },
@@ -98,11 +98,11 @@ module.exports = {
                     const scope = context.getScope();
                     const features = context.parserOptions.ecmaFeatures || {};
 
+                    // `this` at the top level of scripts always refers to the global object
                     stack.push({
                         init: true,
                         node,
                         valid: !(
-                            scope.isStrict ||
                             node.sourceType === "module" ||
                             (features.globalReturn && scope.childScopes[0].isStrict)
                         )

package/lib/rules/operator-assignment.js

@@ -76,8 +76,8 @@ module.exports = {
 
         fixable: "code",
         messages: {
-            replaced: "Assignment (=) can be replaced with operator assignment ({{operator}}=).",
-            unexpected: "Unexpected operator assignment ({{operator}}=) shorthand."
+            replaced: "Assignment (=) can be replaced with operator assignment ({{operator}}).",
+            unexpected: "Unexpected operator assignment ({{operator}}) shorthand."
         }
     },
 
@@ -109,11 +109,13 @@ module.exports = {
             const operator = expr.operator;
 
             if (isCommutativeOperatorWithShorthand(operator) || isNonCommutativeOperatorWithShorthand(operator)) {
+                const replacementOperator = `${operator}=`;
+
                 if (astUtils.isSameReference(left, expr.left, true)) {
                     context.report({
                         node,
                         messageId: "replaced",
-                        data: { operator },
+                        data: { operator: replacementOperator },
                         fix(fixer) {
                             if (canBeFixed(left) && canBeFixed(expr.left)) {
                                 const equalsToken = getOperatorToken(node);
@@ -126,7 +128,7 @@ module.exports = {
                                     return null;
                                 }
 
-                                return fixer.replaceText(node, `${leftText}${expr.operator}=${rightText}`);
+                                return fixer.replaceText(node, `${leftText}${replacementOperator}${rightText}`);
                             }
                             return null;
                         }
@@ -141,7 +143,7 @@ module.exports = {
                     context.report({
                         node,
                         messageId: "replaced",
-                        data: { operator }
+                        data: { operator: replacementOperator }
                     });
                 }
             }

package/lib/rules/padding-line-between-statements.js

@@ -450,8 +450,7 @@ module.exports = {
                             type: "array",
                             items: { enum: Object.keys(StatementTypes) },
                             minItems: 1,
-                            uniqueItems: true,
-                            additionalItems: false
+                            uniqueItems: true
                         }
                     ]
                 }
@@ -466,8 +465,7 @@ module.exports = {
                 },
                 additionalProperties: false,
                 required: ["blankLine", "prev", "next"]
-            },
-            additionalItems: false
+            }
         },
 
         messages: {

package/lib/rules/utils/ast-utils.js

@@ -32,6 +32,7 @@ const thisTagPattern = /^[\s*]*@this/mu;
 
 
 const COMMENTS_IGNORE_PATTERN = /^\s*(?:eslint|jshint\s+|jslint\s+|istanbul\s+|globals?\s+|exported\s+|jscs)/u;
+const ESLINT_DIRECTIVE_PATTERN = /^(?:eslint[- ]|(?:globals?|exported) )/u;
 const LINEBREAKS = new Set(["\r\n", "\r", "\n", "\u2028", "\u2029"]);
 
 // A set of node types that can contain a list of statements
@@ -788,6 +789,203 @@ function getModuleExportName(node) {
     return node.value;
 }
 
+/**
+ * Returns literal's value converted to the Boolean type
+ * @param {ASTNode} node any `Literal` node
+ * @returns {boolean | null} `true` when node is truthy, `false` when node is falsy,
+ *  `null` when it cannot be determined.
+ */
+function getBooleanValue(node) {
+    if (node.value === null) {
+
+        /*
+         * it might be a null literal or bigint/regex literal in unsupported environments .
+         * https://github.com/estree/estree/blob/14df8a024956ea289bd55b9c2226a1d5b8a473ee/es5.md#regexpliteral
+         * https://github.com/estree/estree/blob/14df8a024956ea289bd55b9c2226a1d5b8a473ee/es2020.md#bigintliteral
+         */
+
+        if (node.raw === "null") {
+            return false;
+        }
+
+        // regex is always truthy
+        if (typeof node.regex === "object") {
+            return true;
+        }
+
+        return null;
+    }
+
+    return !!node.value;
+}
+
+/**
+ * Checks if a branch node of LogicalExpression short circuits the whole condition
+ * @param {ASTNode} node The branch of main condition which needs to be checked
+ * @param {string} operator The operator of the main LogicalExpression.
+ * @returns {boolean} true when condition short circuits whole condition
+ */
+function isLogicalIdentity(node, operator) {
+    switch (node.type) {
+        case "Literal":
+            return (operator === "||" && getBooleanValue(node) === true) ||
+                  (operator === "&&" && getBooleanValue(node) === false);
+
+        case "UnaryExpression":
+            return (operator === "&&" && node.operator === "void");
+
+        case "LogicalExpression":
+
+            /*
+             * handles `a && false || b`
+             * `false` is an identity element of `&&` but not `||`
+             */
+            return operator === node.operator &&
+                    (
+                        isLogicalIdentity(node.left, operator) ||
+                        isLogicalIdentity(node.right, operator)
+                    );
+
+        case "AssignmentExpression":
+            return ["||=", "&&="].includes(node.operator) &&
+               operator === node.operator.slice(0, -1) &&
+               isLogicalIdentity(node.right, operator);
+
+       // no default
+    }
+    return false;
+}
+
+/**
+ * Checks if an identifier is a reference to a global variable.
+ * @param {Scope} scope The scope in which the identifier is referenced.
+ * @param {ASTNode} node An identifier node to check.
+ * @returns {boolean} `true` if the identifier is a reference to a global variable.
+ */
+function isReferenceToGlobalVariable(scope, node) {
+    const reference = scope.references.find(ref => ref.identifier === node);
+
+    return Boolean(
+        reference &&
+            reference.resolved &&
+            reference.resolved.scope.type === "global" &&
+            reference.resolved.defs.length === 0
+    );
+}
+
+
+/**
+ * Checks if a  node has a constant truthiness value.
+ * @param {Scope} scope Scope in which the node appears.
+ * @param {ASTNode} node The AST node to check.
+ * @param {boolean} inBooleanPosition `true` if checking the test of a
+ * condition. `false` in all other cases. When `false`, checks if -- for
+ * both string and number -- if coerced to that type, the value will
+ * be constant.
+ * @returns {boolean} true when node's truthiness is constant
+ * @private
+ */
+function isConstant(scope, node, inBooleanPosition) {
+
+    // node.elements can return null values in the case of sparse arrays ex. [,]
+    if (!node) {
+        return true;
+    }
+    switch (node.type) {
+        case "Literal":
+        case "ArrowFunctionExpression":
+        case "FunctionExpression":
+            return true;
+        case "ClassExpression":
+        case "ObjectExpression":
+
+            /**
+             * In theory objects like:
+             *
+             * `{toString: () => a}`
+             * `{valueOf: () => a}`
+             *
+             * Or a classes like:
+             *
+             * `class { static toString() { return a } }`
+             * `class { static valueOf() { return a } }`
+             *
+             * Are not constant verifiably when `inBooleanPosition` is
+             * false, but it's an edge case we've opted not to handle.
+             */
+            return true;
+        case "TemplateLiteral":
+            return (inBooleanPosition && node.quasis.some(quasi => quasi.value.cooked.length)) ||
+                        node.expressions.every(exp => isConstant(scope, exp, false));
+
+        case "ArrayExpression": {
+            if (!inBooleanPosition) {
+                return node.elements.every(element => isConstant(scope, element, false));
+            }
+            return true;
+        }
+
+        case "UnaryExpression":
+            if (
+                node.operator === "void" ||
+                        node.operator === "typeof" && inBooleanPosition
+            ) {
+                return true;
+            }
+
+            if (node.operator === "!") {
+                return isConstant(scope, node.argument, true);
+            }
+
+            return isConstant(scope, node.argument, false);
+
+        case "BinaryExpression":
+            return isConstant(scope, node.left, false) &&
+                            isConstant(scope, node.right, false) &&
+                            node.operator !== "in";
+
+        case "LogicalExpression": {
+            const isLeftConstant = isConstant(scope, node.left, inBooleanPosition);
+            const isRightConstant = isConstant(scope, node.right, inBooleanPosition);
+            const isLeftShortCircuit = (isLeftConstant && isLogicalIdentity(node.left, node.operator));
+            const isRightShortCircuit = (inBooleanPosition && isRightConstant && isLogicalIdentity(node.right, node.operator));
+
+            return (isLeftConstant && isRightConstant) ||
+                        isLeftShortCircuit ||
+                        isRightShortCircuit;
+        }
+        case "NewExpression":
+            return inBooleanPosition;
+        case "AssignmentExpression":
+            if (node.operator === "=") {
+                return isConstant(scope, node.right, inBooleanPosition);
+            }
+
+            if (["||=", "&&="].includes(node.operator) && inBooleanPosition) {
+                return isLogicalIdentity(node.right, node.operator.slice(0, -1));
+            }
+
+            return false;
+
+        case "SequenceExpression":
+            return isConstant(scope, node.expressions[node.expressions.length - 1], inBooleanPosition);
+        case "SpreadElement":
+            return isConstant(scope, node.argument, inBooleanPosition);
+        case "CallExpression":
+            if (node.callee.type === "Identifier" && node.callee.name === "Boolean") {
+                if (node.arguments.length === 0 || isConstant(scope, node.arguments[0], true)) {
+                    return isReferenceToGlobalVariable(scope, node.callee);
+                }
+            }
+            return false;
+        case "Identifier":
+            return node.name === "undefined" && isReferenceToGlobalVariable(scope, node);
+
+                // no default
+    }
+    return false;
+}
+
 //------------------------------------------------------------------------------
 // Public Interface
 //------------------------------------------------------------------------------
@@ -908,12 +1106,8 @@ module.exports = {
         const comment = node.value.trim();
 
         return (
-            node.type === "Line" && comment.indexOf("eslint-") === 0 ||
-            node.type === "Block" && (
-                comment.indexOf("global ") === 0 ||
-                comment.indexOf("eslint ") === 0 ||
-                comment.indexOf("eslint-") === 0
-            )
+            node.type === "Line" && comment.startsWith("eslint-") ||
+            node.type === "Block" && ESLINT_DIRECTIVE_PATTERN.test(comment)
         );
     },
 
@@ -1905,6 +2099,7 @@ module.exports = {
         return OCTAL_OR_NON_OCTAL_DECIMAL_ESCAPE_PATTERN.test(rawString);
     },
 
+    isReferenceToGlobalVariable,
     isLogicalExpression,
     isCoalesceExpression,
     isMixedLogicalAndCoalesceExpressions,
@@ -1918,5 +2113,6 @@ module.exports = {
     isSameReference,
     isLogicalAssignmentOperator,
     getSwitchCaseColonToken,
-    getModuleExportName
+    getModuleExportName,
+    isConstant
 };

package/lib/shared/types.js

@@ -173,3 +173,27 @@ module.exports = {};
  * @property {string} ruleId The rule ID.
  * @property {string[]} replacedBy The rule IDs that replace this deprecated rule.
  */
+
+/**
+ * A linting result.
+ * @typedef {Object} LintResult
+ * @property {string} filePath The path to the file that was linted.
+ * @property {LintMessage[]} messages All of the messages for the result.
+ * @property {SuppressedLintMessage[]} suppressedMessages All of the suppressed messages for the result.
+ * @property {number} errorCount Number of errors for the result.
+ * @property {number} fatalErrorCount Number of fatal errors for the result.
+ * @property {number} warningCount Number of warnings for the result.
+ * @property {number} fixableErrorCount Number of fixable errors for the result.
+ * @property {number} fixableWarningCount Number of fixable warnings for the result.
+ * @property {string} [source] The source code of the file that was linted.
+ * @property {string} [output] The source code of the file that was linted, with as many fixes applied as possible.
+ * @property {DeprecatedRuleInfo[]} usedDeprecatedRules The list of used deprecated rules.
+ */
+
+/**
+ * A formatter function.
+ * @callback FormatterFunction
+ * @param {LintResult[]} results The list of linting results.
+ * @param {{cwd: string, rulesMeta: Record<string, RuleMeta>}} [context] A context object.
+ * @returns {string | Promise<string>} Formatted text.
+ */