eslint 8.34.0 → 8.37.0

package/lib/rules/multiline-comment-style.js

@@ -22,7 +22,37 @@ module.exports = {
         },
 
         fixable: "whitespace",
-        schema: [{ enum: ["starred-block", "separate-lines", "bare-block"] }],
+        schema: {
+            anyOf: [
+                {
+                    type: "array",
+                    items: [
+                        {
+                            enum: ["starred-block", "bare-block"]
+                        }
+                    ],
+                    additionalItems: false
+                },
+                {
+                    type: "array",
+                    items: [
+                        {
+                            enum: ["separate-lines"]
+                        },
+                        {
+                            type: "object",
+                            properties: {
+                                checkJSDoc: {
+                                    type: "boolean"
+                                }
+                            },
+                            additionalProperties: false
+                        }
+                    ],
+                    additionalItems: false
+                }
+            ]
+        },
         messages: {
             expectedBlock: "Expected a block comment instead of consecutive line comments.",
             expectedBareBlock: "Expected a block comment without padding stars.",
@@ -37,6 +67,8 @@ module.exports = {
     create(context) {
         const sourceCode = context.getSourceCode();
         const option = context.options[0] || "starred-block";
+        const params = context.options[1] || {};
+        const checkJSDoc = !!params.checkJSDoc;
 
         //----------------------------------------------------------------------
         // Helpers
@@ -333,11 +365,18 @@ module.exports = {
             "separate-lines"(commentGroup) {
                 const [firstComment] = commentGroup;
 
-                if (firstComment.type !== "Block" || isJSDocComment(commentGroup)) {
+                const isJSDoc = isJSDocComment(commentGroup);
+
+                if (firstComment.type !== "Block" || (!checkJSDoc && isJSDoc)) {
                     return;
                 }
 
-                const commentLines = getCommentLines(commentGroup);
+                let commentLines = getCommentLines(commentGroup);
+
+                if (isJSDoc) {
+                    commentLines = commentLines.slice(1, commentLines.length - 1);
+                }
+
                 const tokenAfter = sourceCode.getTokenAfter(firstComment, { includeComments: true });
 
                 if (tokenAfter && firstComment.loc.end.line === tokenAfter.loc.start.line) {

package/lib/rules/no-alert.js

@@ -101,10 +101,12 @@ module.exports = {
     },
 
     create(context) {
+        const sourceCode = context.getSourceCode();
+
         return {
             CallExpression(node) {
                 const callee = skipChainExpression(node.callee),
-                    currentScope = context.getScope();
+                    currentScope = sourceCode.getScope(node);
 
                 // without window.
                 if (callee.type === "Identifier") {

package/lib/rules/no-catch-shadow.js

@@ -39,6 +39,8 @@ module.exports = {
 
     create(context) {
 
+        const sourceCode = context.getSourceCode();
+
         //--------------------------------------------------------------------------
         // Helpers
         //--------------------------------------------------------------------------
@@ -60,7 +62,7 @@ module.exports = {
         return {
 
             "CatchClause[param!=null]"(node) {
-                let scope = context.getScope();
+                let scope = sourceCode.getScope(node);
 
                 /*
                  * When ecmaVersion >= 6, CatchClause creates its own scope

package/lib/rules/no-console.js

@@ -51,6 +51,7 @@ module.exports = {
     create(context) {
         const options = context.options[0] || {};
         const allowed = options.allow || [];
+        const sourceCode = context.getSourceCode();
 
         /**
          * Checks whether the given reference is 'console' or not.
@@ -109,8 +110,8 @@ module.exports = {
         }
 
         return {
-            "Program:exit"() {
-                const scope = context.getScope();
+            "Program:exit"(node) {
+                const scope = sourceCode.getScope(node);
                 const consoleVar = astUtils.getVariableByName(scope, "console");
                 const shadowed = consoleVar && consoleVar.defs.length > 0;
 

package/lib/rules/no-constant-binary-expression.js

@@ -14,6 +14,23 @@ const NUMERIC_OR_STRING_BINARY_OPERATORS = new Set(["+", "-", "*", "/", "%", "|"
 // Helpers
 //------------------------------------------------------------------------------
 
+/**
+ * Checks whether or not a node is `null` or `undefined`. Similar to the one
+ * found in ast-utils.js, but this one correctly handles the edge case that
+ * `undefined` has been redefined.
+ * @param {Scope} scope Scope in which the expression was found.
+ * @param {ASTNode} node A node to check.
+ * @returns {boolean} Whether or not the node is a `null` or `undefined`.
+ * @public
+ */
+function isNullOrUndefined(scope, node) {
+    return (
+        isNullLiteral(node) ||
+        (node.type === "Identifier" && node.name === "undefined" && isReferenceToGlobalVariable(scope, node)) ||
+        (node.type === "UnaryExpression" && node.operator === "void")
+    );
+}
+
 /**
  * Test if an AST node has a statically knowable constant nullishness. Meaning,
  * it will always resolve to a constant value of either: `null`, `undefined`
@@ -21,9 +38,14 @@ const NUMERIC_OR_STRING_BINARY_OPERATORS = new Set(["+", "-", "*", "/", "%", "|"
  * three states at runtime would return `false`.
  * @param {Scope} scope The scope in which the node was found.
  * @param {ASTNode} node The AST node being tested.
+ * @param {boolean} nonNullish if `true` then nullish values are not considered constant.
  * @returns {boolean} Does `node` have constant nullishness?
  */
-function hasConstantNullishness(scope, node) {
+function hasConstantNullishness(scope, node, nonNullish) {
+    if (nonNullish && isNullOrUndefined(scope, node)) {
+        return false;
+    }
+
     switch (node.type) {
         case "ObjectExpression": // Objects are never nullish
         case "ArrayExpression": // Arrays are never nullish
@@ -45,9 +67,12 @@ function hasConstantNullishness(scope, node) {
             return (functionName === "Boolean" || functionName === "String" || functionName === "Number") &&
                 isReferenceToGlobalVariable(scope, node.callee);
         }
+        case "LogicalExpression": {
+            return node.operator === "??" && hasConstantNullishness(scope, node.right, true);
+        }
         case "AssignmentExpression":
             if (node.operator === "=") {
-                return hasConstantNullishness(scope, node.right);
+                return hasConstantNullishness(scope, node.right, nonNullish);
             }
 
             /*
@@ -80,7 +105,7 @@ function hasConstantNullishness(scope, node) {
         case "SequenceExpression": {
             const last = node.expressions[node.expressions.length - 1];
 
-            return hasConstantNullishness(scope, last);
+            return hasConstantNullishness(scope, last, nonNullish);
         }
         case "Identifier":
             return node.name === "undefined" && isReferenceToGlobalVariable(scope, node);
@@ -348,7 +373,7 @@ function isAlwaysNew(scope, node) {
              * user-defined constructors could return a sentinel
              * object.
              *
-             * Catching these is especially useful for primitive constructures
+             * Catching these is especially useful for primitive constructors
              * which return boxed values, a surprising gotcha' in JavaScript.
              */
             return Object.hasOwnProperty.call(globals.builtin, node.callee.name) &&
@@ -378,24 +403,6 @@ function isAlwaysNew(scope, node) {
     }
 }
 
-/**
- * Checks whether or not a node is `null` or `undefined`. Similar to the one
- * found in ast-utils.js, but this one correctly handles the edge case that
- * `undefined` has been redefined.
- * @param {Scope} scope Scope in which the expression was found.
- * @param {ASTNode} node A node to check.
- * @returns {boolean} Whether or not the node is a `null` or `undefined`.
- * @public
- */
-function isNullOrUndefined(scope, node) {
-    return (
-        isNullLiteral(node) ||
-        (node.type === "Identifier" && node.name === "undefined" && isReferenceToGlobalVariable(scope, node)) ||
-        (node.type === "UnaryExpression" && node.operator === "void")
-    );
-}
-
-
 /**
  * Checks if one operand will cause the result to be constant.
  * @param {Scope} scope Scope in which the expression was found.
@@ -407,14 +414,14 @@ function isNullOrUndefined(scope, node) {
 function findBinaryExpressionConstantOperand(scope, a, b, operator) {
     if (operator === "==" || operator === "!=") {
         if (
-            (isNullOrUndefined(scope, a) && hasConstantNullishness(scope, b)) ||
+            (isNullOrUndefined(scope, a) && hasConstantNullishness(scope, b, false)) ||
             (isStaticBoolean(scope, a) && hasConstantLooseBooleanComparison(scope, b))
         ) {
             return b;
         }
     } else if (operator === "===" || operator === "!==") {
         if (
-            (isNullOrUndefined(scope, a) && hasConstantNullishness(scope, b)) ||
+            (isNullOrUndefined(scope, a) && hasConstantNullishness(scope, b, false)) ||
             (isStaticBoolean(scope, a) && hasConstantStrictBooleanComparison(scope, b))
         ) {
             return b;
@@ -446,19 +453,21 @@ module.exports = {
     },
 
     create(context) {
+        const sourceCode = context.getSourceCode();
+
         return {
             LogicalExpression(node) {
                 const { operator, left } = node;
-                const scope = context.getScope();
+                const scope = sourceCode.getScope(node);
 
                 if ((operator === "&&" || operator === "||") && isConstant(scope, left, true)) {
                     context.report({ node: left, messageId: "constantShortCircuit", data: { property: "truthiness", operator } });
-                } else if (operator === "??" && hasConstantNullishness(scope, left)) {
+                } else if (operator === "??" && hasConstantNullishness(scope, left, false)) {
                     context.report({ node: left, messageId: "constantShortCircuit", data: { property: "nullishness", operator } });
                 }
             },
             BinaryExpression(node) {
-                const scope = context.getScope();
+                const scope = sourceCode.getScope(node);
                 const { right, left, operator } = node;
                 const rightConstantOperand = findBinaryExpressionConstantOperand(scope, left, right, operator);
                 const leftConstantOperand = findBinaryExpressionConstantOperand(scope, right, left, operator);

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

@@ -48,6 +48,7 @@ module.exports = {
         const options = context.options[0] || {},
             checkLoops = options.checkLoops !== false,
             loopSetStack = [];
+        const sourceCode = context.getSourceCode();
 
         let loopsInCurrentScope = new Set();
 
@@ -62,7 +63,7 @@ module.exports = {
          * @private
          */
         function trackConstantConditionLoop(node) {
-            if (node.test && isConstant(context.getScope(), node.test, true)) {
+            if (node.test && isConstant(sourceCode.getScope(node), node.test, true)) {
                 loopsInCurrentScope.add(node);
             }
         }
@@ -87,7 +88,7 @@ module.exports = {
          * @private
          */
         function reportIfConstant(node) {
-            if (node.test && isConstant(context.getScope(), node.test, true)) {
+            if (node.test && isConstant(sourceCode.getScope(node), node.test, true)) {
                 context.report({ node: node.test, messageId: "unexpected" });
             }
         }

package/lib/rules/no-control-regex.js

@@ -5,7 +5,7 @@
 
 "use strict";
 
-const RegExpValidator = require("regexpp").RegExpValidator;
+const RegExpValidator = require("@eslint-community/regexpp").RegExpValidator;
 const collector = new (class {
     constructor() {
         this._source = "";

package/lib/rules/no-else-return.js

@@ -47,6 +47,8 @@ module.exports = {
 
     create(context) {
 
+        const sourceCode = context.getSourceCode();
+
         //--------------------------------------------------------------------------
         // Helpers
         //--------------------------------------------------------------------------
@@ -169,25 +171,24 @@ module.exports = {
 
         /**
          * Display the context report if rule is violated
-         * @param {Node} node The 'else' node
+         * @param {Node} elseNode The 'else' node
          * @returns {void}
          */
-        function displayReport(node) {
-            const currentScope = context.getScope();
+        function displayReport(elseNode) {
+            const currentScope = sourceCode.getScope(elseNode.parent);
 
             context.report({
-                node,
+                node: elseNode,
                 messageId: "unexpected",
                 fix(fixer) {
 
-                    if (!isSafeFromNameCollisions(node, currentScope)) {
+                    if (!isSafeFromNameCollisions(elseNode, currentScope)) {
                         return null;
                     }
 
-                    const sourceCode = context.getSourceCode();
-                    const startToken = sourceCode.getFirstToken(node);
+                    const startToken = sourceCode.getFirstToken(elseNode);
                     const elseToken = sourceCode.getTokenBefore(startToken);
-                    const source = sourceCode.getText(node);
+                    const source = sourceCode.getText(elseNode);
                     const lastIfToken = sourceCode.getTokenBefore(elseToken);
                     let fixedSource, firstTokenOfElseBlock;
 
@@ -203,14 +204,14 @@ module.exports = {
                      * safe to remove the else keyword, because ASI will not add a semicolon
                      * after the if block
                      */
-                    const ifBlockMaybeUnsafe = node.parent.consequent.type !== "BlockStatement" && lastIfToken.value !== ";";
+                    const ifBlockMaybeUnsafe = elseNode.parent.consequent.type !== "BlockStatement" && lastIfToken.value !== ";";
                     const elseBlockUnsafe = /^[([/+`-]/u.test(firstTokenOfElseBlock.value);
 
                     if (ifBlockMaybeUnsafe && elseBlockUnsafe) {
                         return null;
                     }
 
-                    const endToken = sourceCode.getLastToken(node);
+                    const endToken = sourceCode.getLastToken(elseNode);
                     const lastTokenOfElseBlock = sourceCode.getTokenBefore(endToken);
 
                     if (lastTokenOfElseBlock.value !== ";") {
@@ -244,8 +245,8 @@ module.exports = {
                      * Also, to avoid name collisions between two else blocks.
                      */
                     return new FixTracker(fixer, sourceCode)
-                        .retainEnclosingFunction(node)
-                        .replaceTextRange([elseToken.range[0], node.range[1]], fixedSource);
+                        .retainEnclosingFunction(elseNode)
+                        .replaceTextRange([elseToken.range[0], elseNode.range[1]], fixedSource);
                 }
             });
         }

package/lib/rules/no-eval.js

@@ -72,7 +72,7 @@ module.exports = {
         let funcInfo = null;
 
         /**
-         * Pushs a `this` scope (non-arrow function, class static block, or class field initializer) information to the stack.
+         * Pushes 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
@@ -84,7 +84,7 @@ module.exports = {
          * @returns {void}
          */
         function enterThisScope(node) {
-            const strict = context.getScope().isStrict;
+            const strict = sourceCode.getScope(node).isStrict;
 
             funcInfo = {
                 upper: funcInfo,
@@ -221,7 +221,7 @@ module.exports = {
             },
 
             Program(node) {
-                const scope = context.getScope(),
+                const scope = sourceCode.getScope(node),
                     features = context.parserOptions.ecmaFeatures || {},
                     strict =
                         scope.isStrict ||
@@ -239,8 +239,8 @@ module.exports = {
                 };
             },
 
-            "Program:exit"() {
-                const globalScope = context.getScope();
+            "Program:exit"(node) {
+                const globalScope = sourceCode.getScope(node);
 
                 exitThisScope();
                 reportAccessingEval(globalScope);

package/lib/rules/no-extend-native.js

@@ -51,6 +51,7 @@ module.exports = {
     create(context) {
 
         const config = context.options[0] || {};
+        const sourceCode = context.getSourceCode();
         const exceptions = new Set(config.exceptions || []);
         const modifiedBuiltins = new Set(
             Object.keys(globals.builtin)
@@ -159,8 +160,8 @@ module.exports = {
 
         return {
 
-            "Program:exit"() {
-                const globalScope = context.getScope();
+            "Program:exit"(node) {
+                const globalScope = sourceCode.getScope(node);
 
                 modifiedBuiltins.forEach(builtin => {
                     const builtinVar = globalScope.set.get(builtin);

package/lib/rules/no-extra-boolean-cast.js

@@ -10,7 +10,7 @@
 //------------------------------------------------------------------------------
 
 const astUtils = require("./utils/ast-utils");
-const eslintUtils = require("eslint-utils");
+const eslintUtils = require("@eslint-community/eslint-utils");
 
 const precedence = astUtils.getPrecedence;
 

package/lib/rules/no-extra-parens.js

@@ -8,7 +8,7 @@
 // Rule Definition
 //------------------------------------------------------------------------------
 
-const { isParenthesized: isParenthesizedRaw } = require("eslint-utils");
+const { isParenthesized: isParenthesizedRaw } = require("@eslint-community/eslint-utils");
 const astUtils = require("./utils/ast-utils.js");
 
 /** @type {import('../shared/types').Rule} */

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

@@ -41,6 +41,7 @@ module.exports = {
 
     create(context) {
         const config = context.options[0];
+        const sourceCode = context.getSourceCode();
         const exceptions = (config && config.exceptions) || [];
 
         /**
@@ -84,8 +85,8 @@ module.exports = {
         }
 
         return {
-            Program() {
-                const globalScope = context.getScope();
+            Program(node) {
+                const globalScope = sourceCode.getScope(node);
 
                 globalScope.variables.forEach(checkVariable);
             }

package/lib/rules/no-implicit-globals.js

@@ -43,6 +43,7 @@ module.exports = {
     create(context) {
 
         const checkLexicalBindings = context.options[0] && context.options[0].lexicalBindings === true;
+        const sourceCode = context.getSourceCode();
 
         /**
          * Reports the node.
@@ -62,8 +63,8 @@ module.exports = {
         }
 
         return {
-            Program() {
-                const scope = context.getScope();
+            Program(node) {
+                const scope = sourceCode.getScope(node);
 
                 scope.variables.forEach(variable => {
 

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

@@ -10,7 +10,7 @@
 //------------------------------------------------------------------------------
 
 const astUtils = require("./utils/ast-utils");
-const { getStaticValue } = require("eslint-utils");
+const { getStaticValue } = require("@eslint-community/eslint-utils");
 
 //------------------------------------------------------------------------------
 // Rule Definition
@@ -37,6 +37,7 @@ module.exports = {
     create(context) {
         const GLOBAL_CANDIDATES = Object.freeze(["global", "window", "globalThis"]);
         const EVAL_LIKE_FUNC_PATTERN = /^(?:set(?:Interval|Timeout)|execScript)$/u;
+        const sourceCode = context.getSourceCode();
 
         /**
          * Checks whether a node is evaluated as a string or not.
@@ -66,7 +67,7 @@ module.exports = {
 
             if (firstArgument) {
 
-                const staticValue = getStaticValue(firstArgument, context.getScope());
+                const staticValue = getStaticValue(firstArgument, sourceCode.getScope(node));
                 const isStaticString = staticValue && typeof staticValue.value === "string";
                 const isString = isStaticString || isEvaluatedString(firstArgument);
 
@@ -117,8 +118,8 @@ module.exports = {
                     reportImpliedEvalCallExpression(node);
                 }
             },
-            "Program:exit"() {
-                const globalScope = context.getScope();
+            "Program:exit"(node) {
+                const globalScope = sourceCode.getScope(node);
 
                 GLOBAL_CANDIDATES
                     .map(candidate => astUtils.getVariableByName(globalScope, candidate))

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

@@ -9,7 +9,7 @@
 // Helpers
 //------------------------------------------------------------------------------
 
-const { findVariable } = require("eslint-utils");
+const { findVariable } = require("@eslint-community/eslint-utils");
 const astUtils = require("./utils/ast-utils");
 
 const WellKnownMutationFunctions = {
@@ -194,9 +194,11 @@ module.exports = {
     },
 
     create(context) {
+        const sourceCode = context.getSourceCode();
+
         return {
             ImportDeclaration(node) {
-                const scope = context.getScope();
+                const scope = sourceCode.getScope(node);
 
                 for (const variable of context.getDeclaredVariables(node)) {
                     const shouldCheckMembers = variable.defs.some(

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

@@ -8,7 +8,7 @@
 // Requirements
 //------------------------------------------------------------------------------
 
-const RegExpValidator = require("regexpp").RegExpValidator;
+const RegExpValidator = require("@eslint-community/regexpp").RegExpValidator;
 const validator = new RegExpValidator();
 const validFlags = /[dgimsuy]/gu;
 const undefined1 = void 0;

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

@@ -95,7 +95,7 @@ module.exports = {
                 }
 
                 if (codePath.origin === "program") {
-                    const scope = context.getScope();
+                    const scope = sourceCode.getScope(node);
                     const features = context.parserOptions.ecmaFeatures || {};
 
                     // `this` at the top level of scripts always refers to the global object
@@ -120,7 +120,7 @@ module.exports = {
                  * always valid, so we can set `init: true` right away.
                  */
                 stack.push({
-                    init: !context.getScope().isStrict,
+                    init: !sourceCode.getScope(node).isStrict,
                     node,
                     valid: true
                 });

package/lib/rules/no-label-var.js

@@ -34,6 +34,7 @@ module.exports = {
     },
 
     create(context) {
+        const sourceCode = context.getSourceCode();
 
         //--------------------------------------------------------------------------
         // Helpers
@@ -59,7 +60,7 @@ module.exports = {
             LabeledStatement(node) {
 
                 // Fetch the innermost scope.
-                const scope = context.getScope();
+                const scope = sourceCode.getScope(node);
 
                 /*
                  * Recursively find the identifier walking up the scope, starting

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

@@ -33,6 +33,7 @@ module.exports = {
         // A stack of lone blocks to be checked for block-level bindings
         const loneBlocks = [];
         let ruleDef;
+        const sourceCode = context.getSourceCode();
 
         /**
          * Reports a node as invalid.
@@ -120,8 +121,8 @@ module.exports = {
                 }
             };
 
-            ruleDef.FunctionDeclaration = function() {
-                if (context.getScope().isStrict) {
+            ruleDef.FunctionDeclaration = function(node) {
+                if (sourceCode.getScope(node).isStrict) {
                     markLoneBlock();
                 }
             };

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

@@ -168,6 +168,8 @@ module.exports = {
 
     create(context) {
 
+        const sourceCode = context.getSourceCode();
+
         /**
          * Reports functions which match the following condition:
          *
@@ -183,7 +185,7 @@ module.exports = {
                 return;
             }
 
-            const references = context.getScope().through;
+            const references = sourceCode.getScope(node).through;
             const unsafeRefs = references.filter(r => !isSafe(loopNode, r)).map(r => r.identifier.name);
 
             if (unsafeRefs.length > 0) {