feat: add ignoreClassWithStaticInitBlock option to no-unused-vars

docs/src/rules/no-unused-vars.md

@@ -410,6 +410,51 @@ var bar;
 
 :::
 
+### ignoreClassWithStaticInitBlock
+
+The `ignoreClassWithStaticInitBlock` option is a boolean (default: `false`). Static initialization blocks or Static blocks was introduced in ES2022. Static blocks lets us to initialize static variables and execute code during the evaluation of defined class. It means that one don't need to create an instance of class to run the code written inside the static block. This option ignore the classes with static initialization block when sets to `true`.
+
+Examples of **incorrect** code for the `{ "ignoreClassWithStaticInitBlock": true }` option
+
+::: incorrect
+
+```js
+/*eslint no-unused-vars: ["error", { "ignoreClassWithStaticInitBlock": true }]*/
+
+class Foo {
+    static myProperty = "some string";
+    static mymethod() {
+        return "some string";
+    }
+}
+
+class Bar {
+    static {
+        let baz; // unused variable
+    }
+}
+```
+
+:::
+
+Examples of **correct** code for the `{ "ignoreClassWithStaticInitBlock": true }` option
+
+::: correct
+
+```js
+/*eslint no-unused-vars: ["error", { "ignoreClassWithStaticInitBlock": true }]*/
+
+class Foo {
+    static {
+        let bar = "some string";
+
+        console.log(bar);
+    }
+}
+```
+
+:::
+
 ## When Not To Use It
 
 If you don't want to be notified about unused variables or function arguments, you can safely turn this rule off.

lib/rules/no-unused-vars.js

@@ -70,6 +70,9 @@ module.exports = {
                             },
                             destructuredArrayIgnorePattern: {
                                 type: "string"
+                            },
+                            ignoreClassWithStaticInitBlock: {
+                                type: "boolean"
                             }
                         },
                         additionalProperties: false
@@ -92,7 +95,8 @@ module.exports = {
             vars: "all",
             args: "after-used",
             ignoreRestSiblings: false,
-            caughtErrors: "all"
+            caughtErrors: "all",
+            ignoreClassWithStaticInitBlock: false
         };
 
         const firstOption = context.options[0];
@@ -105,6 +109,7 @@ module.exports = {
                 config.args = firstOption.args || config.args;
                 config.ignoreRestSiblings = firstOption.ignoreRestSiblings || config.ignoreRestSiblings;
                 config.caughtErrors = firstOption.caughtErrors || config.caughtErrors;
+                config.ignoreClassWithStaticInitBlock = firstOption.ignoreClassWithStaticInitBlock || config.ignoreClassWithStaticInitBlock;
 
                 if (firstOption.varsIgnorePattern) {
                     config.varsIgnorePattern = new RegExp(firstOption.varsIgnorePattern, "u");
@@ -613,6 +618,14 @@ module.exports = {
                             continue;
                         }
 
+                        if (type === "ClassName") {
+                            const hasStaticBlock = def.node.body.body.some(node => node.type === "StaticBlock");
+
+                            if (config.ignoreClassWithStaticInitBlock && hasStaticBlock) {
+                                continue;
+                            }
+                        }
+
                         // skip catch variables
                         if (type === "CatchClause") {
                             if (config.caughtErrors === "none") {

tests/lib/rules/no-unused-vars.js

@@ -445,6 +445,23 @@ ruleTester.run("no-unused-vars", rule, {
         {
             code: "var a; a ??= 1;",
             languageOptions: { ecmaVersion: 2021 }
+        },
+
+        // ignore class with static initialization block https://github.com/eslint/eslint/issues/17772
+        {
+            code: "class Foo { static {} }",
+            options: [{ ignoreClassWithStaticInitBlock: true }],
+            languageOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: "class Foo { static {} }",
+            options: [{ ignoreClassWithStaticInitBlock: true, varsIgnorePattern: "^_" }],
+            languageOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: "class Foo { static {} }",
+            options: [{ ignoreClassWithStaticInitBlock: false, varsIgnorePattern: "^Foo" }],
+            languageOptions: { ecmaVersion: 2022 }
         }
     ],
     invalid: [
@@ -1557,6 +1574,43 @@ function foo1() {
 c = foo1`,
             languageOptions: { ecmaVersion: 2020 },
             errors: [{ ...assignedError("c"), line: 10, column: 1 }]
+        },
+
+        // ignore class with static initialization block https://github.com/eslint/eslint/issues/17772
+        {
+            code: "class Foo { static {} }",
+            options: [{ ignoreClassWithStaticInitBlock: false }],
+            languageOptions: { ecmaVersion: 2022 },
+            errors: [{ ...definedError("Foo"), line: 1, column: 7 }]
+        },
+        {
+            code: "class Foo { static {} }",
+            languageOptions: { ecmaVersion: 2022 },
+            errors: [{ ...definedError("Foo"), line: 1, column: 7 }]
+        },
+        {
+            code: "class Foo { static { var bar; } }",
+            options: [{ ignoreClassWithStaticInitBlock: true }],
+            languageOptions: { ecmaVersion: 2022 },
+            errors: [{ ...definedError("bar"), line: 1, column: 26 }]
+        },
+        {
+            code: "class Foo {}",
+            options: [{ ignoreClassWithStaticInitBlock: true }],
+            languageOptions: { ecmaVersion: 2022 },
+            errors: [{ ...definedError("Foo"), line: 1, column: 7 }]
+        },
+        {
+            code: "class Foo { static bar; }",
+            options: [{ ignoreClassWithStaticInitBlock: true }],
+            languageOptions: { ecmaVersion: 2022 },
+            errors: [{ ...definedError("Foo"), line: 1, column: 7 }]
+        },
+        {
+            code: "class Foo { static bar() {} }",
+            options: [{ ignoreClassWithStaticInitBlock: true }],
+            languageOptions: { ecmaVersion: 2022 },
+            errors: [{ ...definedError("Foo"), line: 1, column: 7 }]
         }
     ]
 });