eslint 8.2.0 → 8.5.0

package/lib/rules/no-use-before-define.js

@@ -45,25 +45,37 @@ function isInRange(node, location) {
 
 /**
  * Checks whether or not a given location is inside of the range of a class static initializer.
+ * Static initializers are static blocks and initializers of static fields.
  * @param {ASTNode} node `ClassBody` node to check static initializers.
  * @param {number} location A location to check.
  * @returns {boolean} `true` if the location is inside of a class static initializer.
  */
 function isInClassStaticInitializerRange(node, location) {
     return node.body.some(classMember => (
-        classMember.type === "PropertyDefinition" &&
-        classMember.static &&
-        classMember.value &&
-        isInRange(classMember.value, location)
+        (
+            classMember.type === "StaticBlock" &&
+            isInRange(classMember, location)
+        ) ||
+        (
+            classMember.type === "PropertyDefinition" &&
+            classMember.static &&
+            classMember.value &&
+            isInRange(classMember.value, location)
+        )
     ));
 }
 
 /**
- * Checks whether a given scope is the scope of a static class field initializer.
+ * Checks whether a given scope is the scope of a a class static initializer.
+ * Static initializers are static blocks and initializers of static fields.
  * @param {eslint-scope.Scope} scope A scope to check.
  * @returns {boolean} `true` if the scope is a class static initializer scope.
  */
 function isClassStaticInitializerScope(scope) {
+    if (scope.type === "class-static-block") {
+        return true;
+    }
+
     if (scope.type === "class-field-initializer") {
 
         // `scope.block` is PropertyDefinition#value node
@@ -82,7 +94,8 @@ function isClassStaticInitializerScope(scope) {
  * - top-level
  * - functions
  * - class field initializers (implicit functions)
- * Static class field initializers are automatically run during the class definition evaluation,
+ * - class static blocks (implicit functions)
+ * Static class field initializers and class static blocks are automatically run during the class definition evaluation,
  * and therefore we'll consider them as a part of the parent execution context.
  * Example:
  *
@@ -90,6 +103,7 @@ function isClassStaticInitializerScope(scope) {
  *
  *   x; // returns `false`
  *   () => x; // returns `true`
+ *
  *   class C {
  *       field = x; // returns `true`
  *       static field = x; // returns `false`
@@ -97,6 +111,14 @@ function isClassStaticInitializerScope(scope) {
  *       method() {
  *           x; // returns `true`
  *       }
+ *
+ *       static method() {
+ *           x; // returns `true`
+ *       }
+ *
+ *       static {
+ *           x; // returns `false`
+ *       }
  *   }
  * @param {eslint-scope.Reference} reference A reference to check.
  * @returns {boolean} `true` if the reference is from a separate execution context.
@@ -127,8 +149,9 @@ function isFromSeparateExecutionContext(reference) {
  *     var {a = a} = obj
  *     for (var a in a) {}
  *     for (var a of a) {}
- *     var C = class { [C]; }
- *     var C = class { static foo = C; }
+ *     var C = class { [C]; };
+ *     var C = class { static foo = C; };
+ *     var C = class { static { foo = C; } };
  *     class C extends C {}
  *     class C extends (class { static foo = C; }) {}
  *     class C { [C]; }
@@ -158,7 +181,7 @@ function isEvaluatedDuringInitialization(reference) {
 
             /*
              * Class binding is initialized before running static initializers.
-             * For example, `class C { static foo = C; }` is valid.
+             * For example, `class C { static foo = C; static { bar = C; } }` is valid.
              */
             !isInClassStaticInitializerRange(classDefinition.body, location)
         );
@@ -195,6 +218,7 @@ function isEvaluatedDuringInitialization(reference) {
 // Rule Definition
 //------------------------------------------------------------------------------
 
+/** @type {import('../shared/types').Rule} */
 module.exports = {
     meta: {
         type: "problem",

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

@@ -58,6 +58,7 @@ function isNegativeLookaround(node) {
 // Rule Definition
 //------------------------------------------------------------------------------
 
+/** @type {import('../shared/types').Rule} */
 module.exports = {
     meta: {
         type: "problem",

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

@@ -49,6 +49,7 @@ function isValidThisArg(expectedThis, thisArg, sourceCode) {
 // Rule Definition
 //------------------------------------------------------------------------------
 
+/** @type {import('../shared/types').Rule} */
 module.exports = {
     meta: {
         type: "suggestion",

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

@@ -9,6 +9,7 @@
 // Rule Definition
 //------------------------------------------------------------------------------
 
+/** @type {import('../shared/types').Rule} */
 module.exports = {
     meta: {
         type: "suggestion",

package/lib/rules/no-useless-computed-key.js

@@ -85,6 +85,7 @@ function hasUselessComputedKey(node) {
 // Rule Definition
 //------------------------------------------------------------------------------
 
+/** @type {import('../shared/types').Rule} */
 module.exports = {
     meta: {
         type: "suggestion",

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

@@ -64,6 +64,7 @@ function getRight(node) {
 // Rule Definition
 //------------------------------------------------------------------------------
 
+/** @type {import('../shared/types').Rule} */
 module.exports = {
     meta: {
         type: "suggestion",

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

@@ -132,6 +132,7 @@ function isRedundantSuperCall(body, ctorParams) {
 // Rule Definition
 //------------------------------------------------------------------------------
 
+/** @type {import('../shared/types').Rule} */
 module.exports = {
     meta: {
         type: "suggestion",

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

@@ -78,6 +78,7 @@ function parseRegExp(regExpText) {
     return charList;
 }
 
+/** @type {import('../shared/types').Rule} */
 module.exports = {
     meta: {
         type: "suggestion",

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

@@ -15,6 +15,7 @@ const astUtils = require("./utils/ast-utils");
 // Rule Definition
 //------------------------------------------------------------------------------
 
+/** @type {import('../shared/types').Rule} */
 module.exports = {
     meta: {
         type: "suggestion",

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

@@ -61,6 +61,7 @@ function isInFinally(node) {
 // Rule Definition
 //------------------------------------------------------------------------------
 
+/** @type {import('../shared/types').Rule} */
 module.exports = {
     meta: {
         type: "suggestion",

package/lib/rules/no-var.js

@@ -179,6 +179,7 @@ function hasNameDisallowedForLetDeclarations(variable) {
 // Rule Definition
 //------------------------------------------------------------------------------
 
+/** @type {import('../shared/types').Rule} */
 module.exports = {
     meta: {
         type: "suggestion",

package/lib/rules/no-void.js

@@ -8,6 +8,7 @@
 // Rule Definition
 //------------------------------------------------------------------------------
 
+/** @type {import('../shared/types').Rule} */
 module.exports = {
     meta: {
         type: "suggestion",

package/lib/rules/no-warning-comments.js

@@ -14,6 +14,7 @@ const CHAR_LIMIT = 40;
 // Rule Definition
 //------------------------------------------------------------------------------
 
+/** @type {import('../shared/types').Rule} */
 module.exports = {
     meta: {
         type: "suggestion",

package/lib/rules/no-whitespace-before-property.js

@@ -14,6 +14,7 @@ const astUtils = require("./utils/ast-utils");
 // Rule Definition
 //------------------------------------------------------------------------------
 
+/** @type {import('../shared/types').Rule} */
 module.exports = {
     meta: {
         type: "layout",

package/lib/rules/no-with.js

@@ -9,6 +9,7 @@
 // Rule Definition
 //------------------------------------------------------------------------------
 
+/** @type {import('../shared/types').Rule} */
 module.exports = {
     meta: {
         type: "suggestion",

package/lib/rules/nonblock-statement-body-position.js

@@ -10,6 +10,7 @@
 
 const POSITION_SCHEMA = { enum: ["beside", "below", "any"] };
 
+/** @type {import('../shared/types').Rule} */
 module.exports = {
     meta: {
         type: "layout",

package/lib/rules/object-curly-newline.js

@@ -144,6 +144,7 @@ function areLineBreaksRequired(node, options, first, last) {
 // Rule Definition
 //------------------------------------------------------------------------------
 
+/** @type {import('../shared/types').Rule} */
 module.exports = {
     meta: {
         type: "layout",

package/lib/rules/object-curly-spacing.js

@@ -10,6 +10,7 @@ const astUtils = require("./utils/ast-utils");
 // Rule Definition
 //------------------------------------------------------------------------------
 
+/** @type {import('../shared/types').Rule} */
 module.exports = {
     meta: {
         type: "layout",

package/lib/rules/object-property-newline.js

@@ -9,6 +9,7 @@
 // Rule Definition
 //------------------------------------------------------------------------------
 
+/** @type {import('../shared/types').Rule} */
 module.exports = {
     meta: {
         type: "layout",

package/lib/rules/object-shorthand.js

@@ -22,6 +22,7 @@ const astUtils = require("./utils/ast-utils");
 //------------------------------------------------------------------------------
 // Rule Definition
 //------------------------------------------------------------------------------
+/** @type {import('../shared/types').Rule} */
 module.exports = {
     meta: {
         type: "suggestion",

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

@@ -8,6 +8,7 @@
 // Rule Definition
 //------------------------------------------------------------------------------
 
+/** @type {import('../shared/types').Rule} */
 module.exports = {
     meta: {
         type: "suggestion",

package/lib/rules/one-var.js

@@ -28,6 +28,7 @@ function isInStatementList(node) {
 // Rule Definition
 //------------------------------------------------------------------------------
 
+/** @type {import('../shared/types').Rule} */
 module.exports = {
     meta: {
         type: "suggestion",
@@ -541,6 +542,8 @@ module.exports = {
             FunctionDeclaration: startFunction,
             FunctionExpression: startFunction,
             ArrowFunctionExpression: startFunction,
+            StaticBlock: startFunction, // StaticBlock creates a new scope for `var` variables
+
             BlockStatement: startBlock,
             ForStatement: startBlock,
             ForInStatement: startBlock,
@@ -552,10 +555,12 @@ module.exports = {
             "ForInStatement:exit": endBlock,
             "SwitchStatement:exit": endBlock,
             "BlockStatement:exit": endBlock,
+
             "Program:exit": endFunction,
             "FunctionDeclaration:exit": endFunction,
             "FunctionExpression:exit": endFunction,
-            "ArrowFunctionExpression:exit": endFunction
+            "ArrowFunctionExpression:exit": endFunction,
+            "StaticBlock:exit": endFunction
         };
 
     }

package/lib/rules/operator-assignment.js

@@ -57,6 +57,7 @@ function canBeFixed(node) {
     );
 }
 
+/** @type {import('../shared/types').Rule} */
 module.exports = {
     meta: {
         type: "suggestion",

package/lib/rules/operator-linebreak.js

@@ -15,6 +15,7 @@ const astUtils = require("./utils/ast-utils");
 // Rule Definition
 //------------------------------------------------------------------------------
 
+/** @type {import('../shared/types').Rule} */
 module.exports = {
     meta: {
         type: "layout",

package/lib/rules/padded-blocks.js

@@ -15,6 +15,7 @@ const astUtils = require("./utils/ast-utils");
 // Rule Definition
 //------------------------------------------------------------------------------
 
+/** @type {import('../shared/types').Rule} */
 module.exports = {
     meta: {
         type: "layout",
@@ -106,6 +107,12 @@ module.exports = {
             if (node.type === "SwitchStatement") {
                 return sourceCode.getTokenBefore(node.cases[0]);
             }
+
+            if (node.type === "StaticBlock") {
+                return sourceCode.getFirstToken(node, { skip: 1 }); // skip the `static` token
+            }
+
+            // `BlockStatement` or `ClassBody`
             return sourceCode.getFirstToken(node);
         }
 
@@ -172,6 +179,7 @@ module.exports = {
         function requirePaddingFor(node) {
             switch (node.type) {
                 case "BlockStatement":
+                case "StaticBlock":
                     return options.blocks;
                 case "SwitchStatement":
                     return options.switches;
@@ -282,6 +290,7 @@ module.exports = {
                 }
                 checkPadding(node);
             };
+            rule.StaticBlock = rule.BlockStatement;
         }
 
         if (Object.prototype.hasOwnProperty.call(options, "classes")) {

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

@@ -425,6 +425,7 @@ const StatementTypes = {
 // Rule Definition
 //------------------------------------------------------------------------------
 
+/** @type {import('../shared/types').Rule} */
 module.exports = {
     meta: {
         type: "layout",
@@ -618,9 +619,11 @@ module.exports = {
             Program: enterScope,
             BlockStatement: enterScope,
             SwitchStatement: enterScope,
+            StaticBlock: enterScope,
             "Program:exit": exitScope,
             "BlockStatement:exit": exitScope,
             "SwitchStatement:exit": exitScope,
+            "StaticBlock:exit": exitScope,
 
             ":statement": verify,
 

package/lib/rules/prefer-arrow-callback.js

@@ -145,6 +145,7 @@ function hasDuplicateParams(paramsList) {
 // Rule Definition
 //------------------------------------------------------------------------------
 
+/** @type {import('../shared/types').Rule} */
 module.exports = {
     meta: {
         type: "suggestion",

package/lib/rules/prefer-const.js

@@ -17,7 +17,7 @@ const astUtils = require("./utils/ast-utils");
 //------------------------------------------------------------------------------
 
 const PATTERN_TYPE = /^(?:.+?Pattern|RestElement|SpreadProperty|ExperimentalRestProperty|Property)$/u;
-const DECLARATION_HOST_TYPE = /^(?:Program|BlockStatement|SwitchCase)$/u;
+const DECLARATION_HOST_TYPE = /^(?:Program|BlockStatement|StaticBlock|SwitchCase)$/u;
 const DESTRUCTURING_HOST_TYPE = /^(?:VariableDeclarator|AssignmentExpression)$/u;
 
 /**
@@ -326,6 +326,7 @@ function findUp(node, type, shouldStop) {
 // Rule Definition
 //------------------------------------------------------------------------------
 
+/** @type {import('../shared/types').Rule} */
 module.exports = {
     meta: {
         type: "suggestion",

package/lib/rules/prefer-destructuring.js

@@ -20,6 +20,7 @@ const PRECEDENCE_OF_ASSIGNMENT_EXPR = astUtils.getPrecedence({ type: "Assignment
 // Rule Definition
 //------------------------------------------------------------------------------
 
+/** @type {import('../shared/types').Rule} */
 module.exports = {
     meta: {
         type: "suggestion",

package/lib/rules/prefer-exponentiation-operator.js

@@ -84,6 +84,7 @@ function parenthesizeIfShould(text, shouldParenthesize) {
 // Rule Definition
 //------------------------------------------------------------------------------
 
+/** @type {import('../shared/types').Rule} */
 module.exports = {
     meta: {
         type: "suggestion",

package/lib/rules/prefer-named-capture-group.js

@@ -27,6 +27,7 @@ const parser = new regexpp.RegExpParser();
 // Rule Definition
 //------------------------------------------------------------------------------
 
+/** @type {import('../shared/types').Rule} */
 module.exports = {
     meta: {
         type: "suggestion",

package/lib/rules/prefer-numeric-literals.js

@@ -39,6 +39,7 @@ function isParseInt(calleeNode) {
 // Rule Definition
 //------------------------------------------------------------------------------
 
+/** @type {import('../shared/types').Rule} */
 module.exports = {
     meta: {
         type: "suggestion",

package/lib/rules/prefer-object-has-own.js

@@ -0,0 +1,112 @@
+/**
+ * @fileoverview Prefers Object.hasOwn() instead of Object.prototype.hasOwnProperty.call()
+ * @author Nitin Kumar
+ * @author Gautam Arora
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("./utils/ast-utils");
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+/**
+ * Checks if the given node is considered to be an access to a property of `Object.prototype`.
+ * @param {ASTNode} node `MemberExpression` node to evaluate.
+ * @returns {boolean} `true` if `node.object` is `Object`, `Object.prototype`, or `{}` (empty 'ObjectExpression' node).
+ */
+function hasLeftHandObject(node) {
+
+    /*
+     * ({}).hasOwnProperty.call(obj, prop) - `true`
+     * ({ foo }.hasOwnProperty.call(obj, prop)) - `false`, object literal should be empty
+     */
+    if (node.object.type === "ObjectExpression" && node.object.properties.length === 0) {
+        return true;
+    }
+
+    const objectNodeToCheck = node.object.type === "MemberExpression" && astUtils.getStaticPropertyName(node.object) === "prototype" ? node.object.object : node.object;
+
+    if (objectNodeToCheck.type === "Identifier" && objectNodeToCheck.name === "Object") {
+        return true;
+    }
+
+    return false;
+}
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../shared/types').Rule} */
+module.exports = {
+    meta: {
+        type: "suggestion",
+        docs: {
+            description:
+                "disallow use of `Object.prototype.hasOwnProperty.call()` and prefer use of `Object.hasOwn()`",
+            recommended: false,
+            url: "https://eslint.org/docs/rules/prefer-object-has-own"
+        },
+        schema: [],
+        messages: {
+            useHasOwn: "Use 'Object.hasOwn()' instead of 'Object.prototype.hasOwnProperty.call()'."
+        },
+        fixable: "code"
+    },
+    create(context) {
+        return {
+            CallExpression(node) {
+                if (!(node.callee.type === "MemberExpression" && node.callee.object.type === "MemberExpression")) {
+                    return;
+                }
+
+                const calleePropertyName = astUtils.getStaticPropertyName(node.callee);
+                const objectPropertyName = astUtils.getStaticPropertyName(node.callee.object);
+                const isObject = hasLeftHandObject(node.callee.object);
+
+                // check `Object` scope
+                const scope = context.getScope();
+                const variable = astUtils.getVariableByName(scope, "Object");
+
+                if (
+                    calleePropertyName === "call" &&
+                    objectPropertyName === "hasOwnProperty" &&
+                    isObject &&
+                    variable && variable.scope.type === "global"
+                ) {
+                    context.report({
+                        node,
+                        messageId: "useHasOwn",
+                        fix(fixer) {
+                            const sourceCode = context.getSourceCode();
+
+                            if (sourceCode.getCommentsInside(node.callee).length > 0) {
+                                return null;
+                            }
+
+                            const tokenJustBeforeNode = sourceCode.getTokenBefore(node.callee, { includeComments: true });
+
+                            // for https://github.com/eslint/eslint/pull/15346#issuecomment-991417335
+                            if (
+                                tokenJustBeforeNode &&
+                                tokenJustBeforeNode.range[1] === node.callee.range[0] &&
+                                !astUtils.canTokensBeAdjacent(tokenJustBeforeNode, "Object.hasOwn")
+                            ) {
+                                return fixer.replaceText(node.callee, " Object.hasOwn");
+                            }
+
+                            return fixer.replaceText(node.callee, "Object.hasOwn");
+                        }
+                    });
+                }
+            }
+        };
+    }
+};

package/lib/rules/prefer-object-spread.js

@@ -240,6 +240,7 @@ function defineFixer(node, sourceCode) {
     };
 }
 
+/** @type {import('../shared/types').Rule} */
 module.exports = {
     meta: {
         type: "suggestion",

package/lib/rules/prefer-promise-reject-errors.js

@@ -10,6 +10,7 @@ const astUtils = require("./utils/ast-utils");
 // Rule Definition
 //------------------------------------------------------------------------------
 
+/** @type {import('../shared/types').Rule} */
 module.exports = {
     meta: {
         type: "suggestion",

package/lib/rules/prefer-reflect.js

@@ -9,6 +9,7 @@
 // Rule Definition
 //------------------------------------------------------------------------------
 
+/** @type {import('../shared/types').Rule} */
 module.exports = {
     meta: {
         type: "suggestion",