Repository: eslint/eslint
Pull request #15309 (2021-11-13 16:34:46)

fix: update semi-style for class static blocks
<!--
    Thank you for contributing!

    ESLint adheres to the [JS Foundation Code of Conduct](https://js.foundation/community/code-of-conduct).
-->

#### Prerequisites checklist

- [x] I have read the [contributing guidelines](https://github.com/eslint/eslint/blob/HEAD/CONTRIBUTING.md).

#### What is the purpose of this pull request? (put an "X" next to an item)

<!--
    The following template is intentionally not a markdown checkbox list for the reasons
    explained in https://github.com/eslint/eslint/pull/12848#issuecomment-580302888
-->

[ ] Documentation update
[x] Bug fix ([template](https://raw.githubusercontent.com/eslint/eslint/HEAD/templates/bug-report.md))
[ ] New rule ([template](https://raw.githubusercontent.com/eslint/eslint/HEAD/templates/rule-proposal.md))
[ ] Changes an existing rule ([template](https://raw.githubusercontent.com/eslint/eslint/HEAD/templates/rule-change-proposal.md))
[ ] Add autofixing to a rule
[ ] Add a CLI option
[ ] Add something to the core
[ ] Other, please explain:

Refs #15016, fixes `semi-style`.

<!--
    If the item you've checked above has a template, please paste the template questions below and answer them. (If this pull request is addressing an issue, you can just paste a link to the issue here instead.)
-->

<!--
    Please ensure your pull request is ready:

    - Read the pull request guide (https://eslint.org/docs/developer-guide/contributing/pull-requests)
    - Include tests for this change
    - Update documentation for this change (if appropriate)
-->

<!--
    The following is required for all pull requests:
-->

#### What changes did you make? (Give an overview)

Fixed false positive in the `semi-style` rule: the last statement in a class static block should be allowed to have its semicolon on the same line when the option is `"first"`.

```js
/* eslint semi-style: ["error", "first"] */

if (foo) {  
    bar(); // allowed
}

class C {
    method() {
      bar(); // allowed
    }
  
    static {
      bar(); // should be allowed, too
    }
}
```

#### Is there anything you'd like reviewers to focus on?



Patch:
diff --git a/README.md b/README.md
index d5f156a74..bbc74b7ce 100644
--- a/README.md
+++ b/README.md
@@ -207,6 +207,8 @@ These folks keep the project moving and are resources for help.
 
 <!-- NOTE: This section is autogenerated. Do not manually edit.-->
 
+
+
 <!--teamstart-->
 
 ### Technical Steering Committee (TSC)
@@ -290,6 +292,8 @@ Nitin Kumar
 <!--teamend-->
 
 
+
+
 ## <a name="sponsors"></a>Sponsors
 
 The following companies, organizations, and individuals support ESLint's ongoing maintenance and development. [Become a Sponsor](https://opencollective.com/eslint) to get your logo on our README and website.
diff --git a/docs/developer-guide/code-path-analysis.md b/docs/developer-guide/code-path-analysis.md
index 3507ff641..f22eb8f34 100644
--- a/docs/developer-guide/code-path-analysis.md
+++ b/docs/developer-guide/code-path-analysis.md
@@ -27,7 +27,7 @@ This has references of both the initial segment and the final segments of a code
 `CodePath` has the following properties:
 
 * `id` (`string`) - A unique string. Respective rules can use `id` to save additional information for each code path.
-* `origin` (`string`) - The reason that the code path was started. May be `"program"`, `"function"`, or `"class-field-initializer"`.
+* `origin` (`string`) - The reason that the code path was started. May be `"program"`, `"function"`, `"class-field-initializer"`, or `"class-static-block"`.
 * `initialSegment` (`CodePathSegment`) - The initial segment of this code path.
 * `finalSegments` (`CodePathSegment[]`) - The final segments which includes both returned and thrown.
 * `returnedSegments` (`CodePathSegment[]`) - The final segments which includes only returned.
diff --git a/docs/developer-guide/scope-manager-interface.md b/docs/developer-guide/scope-manager-interface.md
index 10ea7446e..2762f74ea 100644
--- a/docs/developer-guide/scope-manager-interface.md
+++ b/docs/developer-guide/scope-manager-interface.md
@@ -77,7 +77,7 @@ Those members are defined but not used in ESLint.
 #### type
 
 * **Type:** `string`
-* **Description:** The type of this scope. This is one of `"block"`, `"catch"`, `"class"`, `"class-field-initializer"`, `"for"`, `"function"`, `"function-expression-name"`, `"global"`, `"module"`, `"switch"`, `"with"`.
+* **Description:** The type of this scope. This is one of `"block"`, `"catch"`, `"class"`, `"class-field-initializer"`, `"class-static-block"`, `"for"`, `"function"`, `"function-expression-name"`, `"global"`, `"module"`, `"switch"`, `"with"`.
 
 #### isStrict
 
@@ -97,9 +97,9 @@ Those members are defined but not used in ESLint.
 #### variableScope
 
 * **Type:** `Scope`
-* **Description:** The nearest ancestor whose `type` is one of `"class-field-initializer"`, `"function"`, `"module"`, or `"program"` . For the aforementioned scopes this is a self-reference.
+* **Description:** The nearest ancestor whose `type` is one of `"class-field-initializer"`, `"class-static-block"`, `"function"`, `"global"`, or `"module"`. For the aforementioned scopes this is a self-reference.
 
-> This represents the lowest enclosing function or top-level scope. Class field initializers are implicit functions. Historically, this was the scope which hosts variables that are defined by `var` declarations, and thus the name `variableScope`.
+> This represents the lowest enclosing function or top-level scope. Class field initializers and class static blocks are implicit functions. Historically, this was the scope which hosts variables that are defined by `var` declarations, and thus the name `variableScope`.
 
 #### block
 
diff --git a/docs/rules/block-spacing.md b/docs/rules/block-spacing.md
index aef7c333c..04c7aeb61 100644
--- a/docs/rules/block-spacing.md
+++ b/docs/rules/block-spacing.md
@@ -23,6 +23,10 @@ if (foo) { bar = 0;}
 function baz() {let i = 0;
     return i;
 }
+
+class C {
+    static {this.bar = 0;}
+}
 ```
 
 Examples of **correct** code for this rule with the default `"always"` option:
@@ -32,6 +36,10 @@ Examples of **correct** code for this rule with the default `"always"` option:
 
 function foo() { return true; }
 if (foo) { bar = 0; }
+
+class C {
+    static { this.bar = 0; }
+}
 ```
 
 ### never
@@ -43,6 +51,10 @@ Examples of **incorrect** code for this rule with the `"never"` option:
 
 function foo() { return true; }
 if (foo) { bar = 0;}
+
+class C {
+    static { this.bar = 0; }
+}
 ```
 
 Examples of **correct** code for this rule with the `"never"` option:
@@ -52,6 +64,10 @@ Examples of **correct** code for this rule with the `"never"` option:
 
 function foo() {return true;}
 if (foo) {bar = 0;}
+
+class C {
+    static {this.bar = 0;}
+}
 ```
 
 ## When Not To Use It
diff --git a/docs/rules/brace-style.md b/docs/rules/brace-style.md
index 1a5bf00aa..c22c790ec 100644
--- a/docs/rules/brace-style.md
+++ b/docs/rules/brace-style.md
@@ -85,6 +85,14 @@ if (foo) {
 else {
   baz();
 }
+
+class C
+{
+    static
+    {
+        foo();
+    }
+}
 ```
 
 Examples of **correct** code for this rule with the default `"1tbs"` option:
@@ -112,6 +120,12 @@ try {
   handleError();
 }
 
+class C {
+    static {
+        foo();
+    }
+}
+
 // when there are no braces, there are no problems
 if (foo) bar();
 else if (baz) boom();
@@ -150,6 +164,12 @@ if (foo) { baz(); } else if (bar) {
 try { somethingRisky(); } catch(e) {
   handleError();
 }
+
+class C {
+    static { foo(); }
+}
+
+class D { static { foo(); } }
 ```
 
 ### stroustrup
@@ -177,6 +197,14 @@ try
   handleError();
 }
 
+class C
+{
+    static
+    {
+        foo();
+    }
+}
+
 if (foo) {
   bar();
 } else {
@@ -211,6 +239,12 @@ catch(e) {
   handleError();
 }
 
+class C {
+    static {
+        foo();
+    }
+}
+
 // when there are no braces, there are no problems
 if (foo) bar();
 else if (baz) boom();
@@ -230,6 +264,12 @@ else { baz(); }
 
 try { somethingRisky(); }
 catch(e) { handleError(); }
+
+class C {
+    static { foo(); }
+}
+
+class D { static { foo(); } }
 ```
 
 ### allman
@@ -255,6 +295,12 @@ try
   handleError();
 }
 
+class C {
+    static {
+        foo();
+    }
+}
+
 if (foo) {
   bar();
 } else {
@@ -295,6 +341,14 @@ catch(e)
   handleError();
 }
 
+class C
+{
+    static
+    {
+        foo();
+    }
+}
+
 // when there are no braces, there are no problems
 if (foo) bar();
 else if (baz) boom();
@@ -314,6 +368,16 @@ else { baz(); }
 
 try { somethingRisky(); }
 catch(e) { handleError(); }
+
+class C
+{
+    static { foo(); }
+
+    static
+    { foo(); }
+}
+
+class D { static { foo(); } }
 ```
 
 ## When Not To Use It
diff --git a/docs/rules/class-methods-use-this.md b/docs/rules/class-methods-use-this.md
index 9d3ca7f19..73efc9dba 100644
--- a/docs/rules/class-methods-use-this.md
+++ b/docs/rules/class-methods-use-this.md
@@ -83,6 +83,10 @@ class A {
     static foo() {
         // OK. static methods aren't expected to use this.
     }
+
+    static {
+        // OK. static blocks are exempt.
+    }
 }
 ```
 
diff --git a/docs/rules/complexity.md b/docs/rules/complexity.md
index f6413d6c5..7955d1a28 100644
--- a/docs/rules/complexity.md
+++ b/docs/rules/complexity.md
@@ -57,7 +57,7 @@ function b() {
 }
 ```
 
-Class field initializers are implicit functions. Therefore, their complexity is calculated separately for each initializer, and it doesn't contribute to the complexity of the enclosing code.
+Class field initializers and class static blocks are implicit functions. Therefore, their complexity is calculated separately for each initializer and each static block, and it doesn't contribute to the complexity of the enclosing code.
 
 Examples of additional **incorrect** code for a maximum of 2:
 
@@ -67,6 +67,14 @@ Examples of additional **incorrect** code for a maximum of 2:
 class C {
     x = a || b || c; // this initializer has complexity = 3
 }
+
+class D { // this static block has complexity = 3
+    static {
+        if (foo) {
+            bar = baz || qux;
+        }
+    }
+}
 ```
 
 Examples of additional **correct** code for a maximum of 2:
@@ -82,6 +90,16 @@ function foo() { // this function has complexity = 1
 
         static p = g || h; // this initializer has complexity = 2
         static q = i ? j : k; // this initializer has complexity = 2
+
+        static { // this static block has complexity = 2
+            if (foo) {
+                baz = bar;
+            }
+        }
+
+        static { // this static block has complexity = 2
+            qux = baz || quux;
+        }
     }
 }
 ```
diff --git a/docs/rules/indent.md b/docs/rules/indent.md
index 2a626604e..74fb0e7e2 100644
--- a/docs/rules/indent.md
+++ b/docs/rules/indent.md
@@ -79,6 +79,8 @@ This rule has an object option:
 * `"FunctionExpression"` takes an object to define rules for function expressions.
     * `parameters` (default: 1) enforces indentation level for parameters in a function expression. This can either be a number indicating indentation level, or the string `"first"` indicating that all parameters of the expression must be aligned with the first parameter. This can also be set to `"off"` to disable checking for FunctionExpression parameters.
     * `body` (default: 1) enforces indentation level for the body of a function expression.
+* `"StaticBlock"` takes an object to define rules for class static blocks.
+    * `body` (default: 1) enforces indentation level for the body of a class static block.
 * `"CallExpression"` takes an object to define rules for function call expressions.
     * `arguments` (default: 1) enforces indentation level for arguments in a call expression. This can either be a number indicating indentation level, or the string `"first"` indicating that all arguments of the expression must be aligned with the first argument. This can also be set to `"off"` to disable checking for CallExpression arguments.
 * `"ArrayExpression"` (default: 1) enforces indentation level for elements in arrays. It can also be set to the string `"first"`, indicating that all the elements in the array should be aligned with the first element. This can also be set to `"off"` to disable checking for array elements.
@@ -484,6 +486,56 @@ var foo = function(bar, baz,
 }
 ```
 
+### StaticBlock
+
+Examples of **incorrect** code for this rule with the `2, { "StaticBlock": {"body": 1} }` option:
+
+```js
+/*eslint indent: ["error", 2, { "StaticBlock": {"body": 1} }]*/
+
+class C {
+  static {
+      foo();
+  }
+}
+```
+
+Examples of **correct** code for this rule with the `2, { "StaticBlock": {"body": 1} }` option:
+
+```js
+/*eslint indent: ["error", 2, { "StaticBlock": {"body": 1} }]*/
+
+class C {
+  static {
+    foo();
+  }
+}
+```
+
+Examples of **incorrect** code for this rule with the `2, { "StaticBlock": {"body": 2} }` option:
+
+```js
+/*eslint indent: ["error", 2, { "StaticBlock": {"body": 2} }]*/
+
+class C {
+  static {
+    foo();
+  }
+}
+```
+
+Examples of **correct** code for this rule with the `2, { "StaticBlock": {"body": 2} }` option:
+
+```js
+/*eslint indent: ["error", 2, { "StaticBlock": {"body": 2} }]*/
+
+class C {
+  static {
+      foo();
+  }
+}
+```
+
 ### CallExpression
 
 Examples of **incorrect** code for this rule with the `2, { "CallExpression": {"arguments": 1} }` option:
diff --git a/docs/rules/keyword-spacing.md b/docs/rules/keyword-spacing.md
index 0cc952dc9..8ca673937 100644
--- a/docs/rules/keyword-spacing.md
+++ b/docs/rules/keyword-spacing.md
@@ -243,13 +243,14 @@ if(foo) {
 
 ### overrides
 
-Examples of **correct** code for this rule with the `{ "overrides": { "if": { "after": false }, "for": { "after": false }, "while": { "after": false } } }` option:
+Examples of **correct** code for this rule with the `{ "overrides": { "if": { "after": false }, "for": { "after": false }, "while": { "after": false }, "static": { "after": false } } }` option:
 
 ```js
 /*eslint keyword-spacing: ["error", { "overrides": {
   "if": { "after": false },
   "for": { "after": false },
-  "while": { "after": false }
+  "while": { "after": false },
+  "static": { "after": false }
 } }]*/
 
 if(foo) {
@@ -263,7 +264,13 @@ if(foo) {
 for(;;);
 
 while(true) {
-  //...
+    //...
+}
+
+class C {
+    static{
+        //...
+    }
 }
 ```
 
diff --git a/docs/rules/lines-around-comment.md b/docs/rules/lines-around-comment.md
index ae543bd83..fb0161102 100644
--- a/docs/rules/lines-around-comment.md
+++ b/docs/rules/lines-around-comment.md
@@ -15,8 +15,8 @@ This rule has an object option:
 * `"afterBlockComment": true` requires an empty line after block comments
 * `"beforeLineComment": true` requires an empty line before line comments
 * `"afterLineComment": true` requires an empty line after line comments
-* `"allowBlockStart": true` allows comments to appear at the start of block statements
-* `"allowBlockEnd": true` allows comments to appear at the end of block statements
+* `"allowBlockStart": true` allows comments to appear at the start of block statements, function bodies, classes, and class static blocks
+* `"allowBlockEnd": true` allows comments to appear at the end of block statements, function bodies, classes, and class static blocks
 * `"allowObjectStart": true` allows comments to appear at the start of object literals
 * `"allowObjectEnd": true` allows comments to appear at the end of object literals
 * `"allowArrayStart": true` allows comments to appear at the start of array literals
@@ -133,6 +133,25 @@ function foo(){
     var day = "great"
     return day;
 }
+
+if (bar) {
+    // what a great and wonderful day
+    foo();
+}
+
+class C {
+    // what a great and wonderful day
+
+    method() {
+        // what a great and wonderful day
+        foo();
+    }
+
+    static {
+        // what a great and wonderful day
+        foo();
+    }
+}
 ```
 
 Examples of **correct** code for this rule with the `{ "beforeBlockComment": true, "allowBlockStart": true }` options:
@@ -145,6 +164,25 @@ function foo(){
     var day = "great"
     return day;
 }
+
+if (bar) {
+    /* what a great and wonderful day */
+    foo();
+}
+
+class C {
+    /* what a great and wonderful day */
+
+    method() {
+        /* what a great and wonderful day */
+        foo();
+    }
+
+    static {
+        /* what a great and wonderful day */
+        foo();
+    }
+}
 ```
 
 ### allowBlockEnd
@@ -159,6 +197,26 @@ function foo(){
     return day;
     // what a great and wonderful day
 }
+
+if (bar) {
+    foo();
+    // what a great and wonderful day
+}
+
+class C {
+
+    method() {
+        foo();
+        // what a great and wonderful day
+    }
+
+    static {
+        foo();
+        // what a great and wonderful day
+    }
+
+    // what a great and wonderful day
+}
 ```
 
 Examples of **correct** code for this rule with the `{ "afterBlockComment": true, "allowBlockEnd": true }` option:
@@ -172,6 +230,29 @@ function foo(){
 
     /* what a great and wonderful day */
 }
+
+if (bar) {
+    foo();
+
+    /* what a great and wonderful day */
+}
+
+class C {
+
+    method() {
+        foo();
+
+        /* what a great and wonderful day */
+    }
+
+    static {
+        foo();
+
+        /* what a great and wonderful day */
+    }
+
+    /* what a great and wonderful day */
+}
 ```
 
 ### allowClassStart
diff --git a/docs/rules/max-depth.md b/docs/rules/max-depth.md
index b853d0267..ae8121e69 100644
--- a/docs/rules/max-depth.md
+++ b/docs/rules/max-depth.md
@@ -20,7 +20,6 @@ Examples of **incorrect** code for this rule with the default `{ "max": 4 }` opt
 
 ```js
 /*eslint max-depth: ["error", 4]*/
-/*eslint-env es6*/
 
 function foo() {
     for (;;) { // Nested 1 deep
@@ -40,7 +39,6 @@ Examples of **correct** code for this rule with the default `{ "max": 4 }` optio
 
 ```js
 /*eslint max-depth: ["error", 4]*/
-/*eslint-env es6*/
 
 function foo() {
     for (;;) { // Nested 1 deep
@@ -54,6 +52,48 @@ function foo() {
 }
 ```
 
+Note that class static blocks do not count as nested blocks, and that the depth in them is calculated separately from the enclosing context.
+
+Examples of **incorrect** code for this rule with `{ "max": 2 }` option:
+
+```js
+/*eslint max-depth: ["error", 2]*/
+
+function foo() {
+    if (true) { // Nested 1 deep
+        class C {
+            static {
+                if (true) { // Nested 1 deep
+                    if (true) { // Nested 2 deep
+                        if (true) { // Nested 3 deep
+                        }
+                    }
+                }
+            }
+        }
+    }
+}
+```
+
+Examples of **correct** code for this rule with `{ "max": 2 }` option:
+
+```js
+/*eslint max-depth: ["error", 2]*/
+
+function foo() {
+    if (true) { // Nested 1 deep
+        class C {
+            static {
+                if (true) { // Nested 1 deep
+                    if (true) { // Nested 2 deep
+                    }
+                }
+            }
+        }
+    }
+}
+```
+
 ## Related Rules
 
 * [complexity](complexity.md)
diff --git a/docs/rules/max-statements.md b/docs/rules/max-statements.md
index 6ef87c2f8..c2a673310 100644
--- a/docs/rules/max-statements.md
+++ b/docs/rules/max-statements.md
@@ -112,6 +112,30 @@ let foo = () => {
 }
 ```
 
+Note that this rule does not apply to class static blocks, and that statements in class static blocks do not count as statements in the enclosing function.
+
+Examples of **correct** code for this rule with `{ "max": 2 }` option:
+
+```js
+/*eslint max-statements: ["error", 2]*/
+
+function foo() {
+    let one;
+    let two = class {
+        static {
+            let three;
+            let four;
+            let five;
+            if (six) {
+                let seven;
+                let eight;
+                let nine;
+            }
+        }
+    };
+}
+```
+
 ### ignoreTopLevelFunctions
 
 Examples of additional **correct** code for this rule with the `{ "max": 10 }, { "ignoreTopLevelFunctions": true }` options:
diff --git a/docs/rules/no-eval.md b/docs/rules/no-eval.md
index 9f7b71ad6..4a2a3b797 100644
--- a/docs/rules/no-eval.md
+++ b/docs/rules/no-eval.md
@@ -66,6 +66,14 @@ class A {
 
     eval() {
     }
+
+    static {
+        // This is a user-defined static method.
+        this.eval("var a = 0");
+    }
+
+    static eval() {
+    }
 }
 ```
 
diff --git a/docs/rules/no-extra-semi.md b/docs/rules/no-extra-semi.md
index f4dd8e09c..a33a493c8 100644
--- a/docs/rules/no-extra-semi.md
+++ b/docs/rules/no-extra-semi.md
@@ -17,6 +17,17 @@ function foo() {
     // code
 };
 
+class C {
+    field;;
+
+    method() {
+        // code
+    };
+
+    static {
+        // code
+    };
+};
 ```
 
 Examples of **correct** code for this rule:
@@ -26,10 +37,25 @@ Examples of **correct** code for this rule:
 
 var x = 5;
 
-var foo = function() {
+function foo() {
+    // code
+}
+
+var bar = function() {
     // code
 };
 
+class C {
+    field;
+
+    method() {
+        // code
+    }
+
+    static {
+        // code
+    }
+}
 ```
 
 ## When Not To Use It
diff --git a/docs/rules/no-inner-declarations.md b/docs/rules/no-inner-declarations.md
index 9bdfaa7c4..7c64e9dc1 100644
--- a/docs/rules/no-inner-declarations.md
+++ b/docs/rules/no-inner-declarations.md
@@ -56,7 +56,7 @@ function doSomething() {
 
 ## Rule Details
 
-This rule requires that function declarations and, optionally, variable declarations be in the root of a program or the body of a function.
+This rule requires that function declarations and, optionally, variable declarations be in the root of a program, or in the root of the body of a function, or in the root of the body of a class static block.
 
 ## Options
 
@@ -83,6 +83,14 @@ function doSomethingElse() {
 }
 
 if (foo) function f(){}
+
+class C {
+    static {
+        if (test) {
+            function doSomething() { }
+        }
+    }
+}
 ```
 
 Examples of **correct** code for this rule with the default `"functions"` option:
@@ -96,6 +104,12 @@ function doSomethingElse() {
     function doAnotherThing() { }
 }
 
+class C {
+    static {
+        function doSomething() { }
+    }
+}
+
 if (test) {
     asyncCall(id, function (err, data) { });
 }
@@ -125,17 +139,23 @@ function doAnotherThing() {
     }
 }
 
-
 if (foo) var a;
 
 if (foo) function f(){}
+
+class C {
+    static {
+        if (test) {
+            var something;
+        }
+    }
+}
 ```
 
 Examples of **correct** code for this rule with the `"both"` option:
 
 ```js
 /*eslint no-inner-declarations: ["error", "both"]*/
-/*eslint-env es6*/
 
 var bar = 42;
 
@@ -146,6 +166,12 @@ if (test) {
 function doAnotherThing() {
     var baz = 81;
 }
+
+class C {
+    static {
+        var something;
+    }
+}
 ```
 
 ## When Not To Use It
diff --git a/docs/rules/no-invalid-this.md b/docs/rules/no-invalid-this.md
index 7614b59a8..f2f17d41a 100644
--- a/docs/rules/no-invalid-this.md
+++ b/docs/rules/no-invalid-this.md
@@ -18,7 +18,7 @@ This rule judges from following conditions whether or not the function is a meth
 
 * The function is on an object literal.
 * The function is assigned to a property.
-* The function is a method/getter/setter of ES2015 Classes. (excepts static methods)
+* The function is a method/getter/setter of ES2015 Classes.
 
 And this rule allows `this` keywords in functions below:
 
@@ -26,6 +26,11 @@ And this rule allows `this` keywords in functions below:
 * The function is a callback of array methods (such as `.forEach()`) if `thisArg` is given.
 * The function has `@this` tag in its JSDoc comment.
 
+And this rule always allows `this` keywords in the following contexts:
+
+* In class field initializers.
+* In class static blocks.
+
 Otherwise are considered problems.
 
 This rule applies **only** in strict mode.
@@ -166,6 +171,13 @@ Foo.prototype.foo = function foo() {
 };
 
 class Foo {
+
+    // OK, this is in a class field initializer.
+    a = this.b;
+
+    // OK, static initializers also have valid this.
+    static a = this.b;
+
     foo() {
         // OK, this is in a method.
         this.a = 0;
@@ -177,6 +189,12 @@ class Foo {
         this.a = 0;
         baz(() => this);
     }
+
+    static {
+        // OK, static blocks also have valid this.
+        this.a = 0;
+        baz(() => this);
+    }
 }
 
 var foo = (function foo() {
diff --git a/docs/rules/no-lone-blocks.md b/docs/rules/no-lone-blocks.md
index 8cb45d635..49fdda6f8 100644
--- a/docs/rules/no-lone-blocks.md
+++ b/docs/rules/no-lone-blocks.md
@@ -42,6 +42,14 @@ function bar() {
     aLabel: {
     }
 }
+
+class C {
+    static {
+        {
+            foo();
+        }
+    }
+}
 ```
 
 Examples of **correct** code for this rule with ES6 environment:
@@ -78,6 +86,18 @@ function bar() {
 
 aLabel: {
 }
+
+class C {
+    static {
+        lbl: {
+            if (something) {
+                break lbl;
+            }
+
+            foo();
+        }
+    }
+}
 ```
 
 Examples of **correct** code for this rule with ES6 environment and strict mode via `"parserOptions": { "sourceType": "module" }` in the ESLint configuration or `"use strict"` directive in the code:
diff --git a/docs/rules/no-redeclare.md b/docs/rules/no-redeclare.md
index c3b8422cf..bd029ebc1 100644
--- a/docs/rules/no-redeclare.md
+++ b/docs/rules/no-redeclare.md
@@ -13,6 +13,18 @@ Examples of **incorrect** code for this rule:
 
 var a = 3;
 var a = 10;
+
+class C {
+    foo() {
+        var b = 3;
+        var b = 10;
+    }
+
+    static {
+        var c = 3;
+        var c = 10;
+    }
+}
 ```
 
 Examples of **correct** code for this rule:
@@ -21,8 +33,20 @@ Examples of **correct** code for this rule:
 /*eslint no-redeclare: "error"*/
 
 var a = 3;
-// ...
 a = 10;
+
+class C {
+    foo() {
+        var b = 3;
+        b = 10;
+    }
+
+    static {
+        var c = 3;
+        c = 10;
+    }
+}
+
 ```
 
 ## Options
diff --git a/docs/rules/one-var.md b/docs/rules/one-var.md
index 3c964c4a4..df7ee1f60 100644
--- a/docs/rules/one-var.md
+++ b/docs/rules/one-var.md
@@ -66,7 +66,6 @@ Examples of **incorrect** code for this rule with the default `"always"` option:
 
 ```js
 /*eslint one-var: ["error", "always"]*/
-/*eslint-env es6*/
 
 function foo() {
     var bar;
@@ -89,13 +88,31 @@ function foo() {
         var qux = true;
     }
 }
+
+class C {
+    static {
+        var foo;
+        var bar;
+    }
+
+    static {
+        var foo;
+        if (bar) {
+            var baz = true;
+        }
+    }
+
+    static {
+        let foo;
+        let bar;
+    }
+}
 ```
 
 Examples of **correct** code for this rule with the default `"always"` option:
 
 ```js
 /*eslint one-var: ["error", "always"]*/
-/*eslint-env es6*/
 
 function foo() {
     var bar,
@@ -127,6 +144,30 @@ function foo(){
         let qux;
     }
 }
+
+class C {
+    static {
+        var foo, bar;
+    }
+
+    static {
+        var foo, baz;
+        if (bar) {
+            baz = true;
+        }
+    }
+
+    static {
+        let foo, bar;
+    }
+
+    static {
+        let foo;
+        if (bar) {
+            let baz;
+        }
+    }
+}
 ```
 
 ### never
@@ -135,7 +176,6 @@ Examples of **incorrect** code for this rule with the `"never"` option:
 
 ```js
 /*eslint one-var: ["error", "never"]*/
-/*eslint-env es6*/
 
 function foo() {
     var bar,
@@ -157,13 +197,19 @@ function foo(){
     let bar = true,
         baz = false;
 }
+
+class C {
+    static {
+        var foo, bar;
+        let baz, qux;
+    }
+}
 ```
 
 Examples of **correct** code for this rule with the `"never"` option:
 
 ```js
 /*eslint one-var: ["error", "never"]*/
-/*eslint-env es6*/
 
 function foo() {
     var bar;
@@ -185,6 +231,15 @@ function foo() {
         let qux = true;
     }
 }
+
+class C {
+    static {
+        var foo;
+        var bar;
+        let baz;
+        let qux;
+    }
+}
 ```
 
 ### consecutive
@@ -193,7 +248,6 @@ Examples of **incorrect** code for this rule with the `"consecutive"` option:
 
 ```js
 /*eslint one-var: ["error", "consecutive"]*/
-/*eslint-env es6*/
 
 function foo() {
     var bar;
@@ -209,14 +263,21 @@ function foo(){
     var qux = 3;
     var quux;
 }
+
+class C {
+    static {
+        var foo;
+        var bar;
+        let baz;
+        let qux;
+    }
+}
 ```
 
 Examples of **correct** code for this rule with the `"consecutive"` option:
 
 ```js
 /*eslint one-var: ["error", "consecutive"]*/
-/*eslint-env es6*/
-
 
 function foo() {
     var bar,
@@ -232,6 +293,16 @@ function foo(){
     var qux = 3,
         quux;
 }
+
+class C {
+    static {
+        var foo, bar;
+        let baz, qux;
+        doSomething();
+        let quux;
+        var quuux;
+    }
+}
 ```
 
 ### var, let, and const
diff --git a/docs/rules/padded-blocks.md b/docs/rules/padded-blocks.md
index d8b855ed3..85c0a8b9c 100644
--- a/docs/rules/padded-blocks.md
+++ b/docs/rules/padded-blocks.md
@@ -27,12 +27,12 @@ The second one is an object option, it can allow exceptions.
 
 String option:
 
-* `"always"` (default) requires empty lines at the beginning and ending of block statements and classes
-* `"never"` disallows empty lines at the beginning and ending of block statements and classes
+* `"always"` (default) requires empty lines at the beginning and ending of block statements, function bodies, class static blocks, classes, and `switch` statements.
+* `"never"` disallows empty lines at the beginning and ending of block statements, function bodies, class static blocks, classes, and `switch` statements.
 
 Object option:
 
-* `"blocks"` require or disallow padding within block statements
+* `"blocks"` require or disallow padding within block statements, function bodies, and class static blocks
 * `"classes"` require or disallow padding within classes
 * `"switches"` require or disallow padding within `switch` statements
 
@@ -68,6 +68,12 @@ if (a) {
     b();
 
 }
+
+class C {
+    static {
+        a();
+    }
+}
 ```
 
 Examples of **correct** code for this rule with the default `"always"` option:
@@ -93,6 +99,16 @@ if (a) {
     // comment
     b();
 
+}
+
+class C {
+
+    static {
+
+        a();
+
+    }
+
 }
 ```
 
@@ -124,6 +140,16 @@ if (a) {
 if (a) {
     b();
 
+}
+
+class C {
+
+    static {
+
+        a();
+
+    }
+
 }
 ```
 
@@ -140,6 +166,12 @@ if (a)
 {
     b();
 }
+
+class C {
+    static {
+        a();
+    }
+}
 ```
 
 ### blocks
@@ -174,6 +206,14 @@ if (a) {
     // comment
     b();
 
+}
+
+class C {
+
+    static {
+        a();
+    }
+
 }
 ```
 
@@ -200,6 +240,25 @@ if (a) {
     // comment
     b();
 
+}
+
+class C {
+
+    static {
+
+        a();
+
+    }
+
+}
+
+class D {
+    static {
+
+        a();
+
+    }
+
 }
 ```
 
@@ -230,6 +289,14 @@ if (a) {
     b();
 
 }
+
+class C {
+    static {
+
+        a();
+
+    }
+}
 ```
 
 Examples of **correct** code for this rule with the `{ "blocks": "never" }` option:
@@ -245,6 +312,20 @@ if (a)
 {
     b();
 }
+
+class C {
+    static {
+        a();
+    }
+}
+
+class D {
+
+    static {
+        a();
+    }
+
+}
 ```
 
 ### classes
diff --git a/docs/rules/padding-line-between-statements.md b/docs/rules/padding-line-between-statements.md
index 2f2f67ee0..065c7d937 100644
--- a/docs/rules/padding-line-between-statements.md
+++ b/docs/rules/padding-line-between-statements.md
@@ -147,6 +147,13 @@ function foo() {
     const a = 0;
     bar();
 }
+
+class C {
+    static {
+        let a = 0;
+        bar();
+    }
+}
 ```
 
 Examples of **correct** code for the `[{ blankLine: "always", prev: ["const", "let", "var"], next: "*"}, { blankLine: "any", prev: ["const", "let", "var"], next: ["const", "let", "var"]}]` configuration:
@@ -178,6 +185,15 @@ function foo() {
 
     bar();
 }
+
+class C {
+    static {
+        let a = 0;
+        let b = 0;
+
+        bar();
+    }
+}
 ```
 
 ----
diff --git a/docs/rules/prefer-const.md b/docs/rules/prefer-const.md
index 3e5a5d0c3..3cdba9e4d 100644
--- a/docs/rules/prefer-const.md
+++ b/docs/rules/prefer-const.md
@@ -12,7 +12,6 @@ Examples of **incorrect** code for this rule:
 
 ```js
 /*eslint prefer-const: "error"*/
-/*eslint-env es6*/
 
 // it's initialized and never reassigned.
 let a = 3;
@@ -22,6 +21,14 @@ let a;
 a = 0;
 console.log(a);
 
+class C {
+    static {
+        let a;
+        a = 0;
+        console.log(a);
+    }
+}
+
 // `i` is redefined (not reassigned) on each loop step.
 for (let i in [1, 2, 3]) {
     console.log(i);
@@ -37,7 +44,6 @@ Examples of **correct** code for this rule:
 
 ```js
 /*eslint prefer-const: "error"*/
-/*eslint-env es6*/
 
 // using const.
 const a = 0;
@@ -59,6 +65,15 @@ if (true) {
 }
 console.log(a);
 
+// it's initialized in a different scope.
+let a;
+class C {
+    #x;
+    static {
+        a = obj => obj.#x;
+    }
+}
+
 // it's initialized at a place that we cannot write a variable declaration.
 let a;
 if (true) a = 0;
diff --git a/docs/rules/semi-style.md b/docs/rules/semi-style.md
index 7bd916f9d..368bb532a 100644
--- a/docs/rules/semi-style.md
+++ b/docs/rules/semi-style.md
@@ -32,6 +32,13 @@ for (
 ) {
     foo()
 }
+
+class C {
+    static {
+        foo()
+        ;bar()
+    }
+}
 ```
 
 Examples of **correct** code for this rule with `"last"` option:
@@ -49,6 +56,13 @@ for (
 ) {
     foo()
 }
+
+class C {
+    static {
+        foo();
+        bar()
+    }
+}
 ```
 
 Examples of **incorrect** code for this rule with `"first"` option:
@@ -66,6 +80,13 @@ for (
 ) {
     foo()
 }
+
+class C {
+    static {
+        foo();
+        bar()
+    }
+}
 ```
 
 Examples of **correct** code for this rule with `"first"` option:
@@ -83,6 +104,13 @@ for (
 ) {
     foo()
 }
+
+class C {
+    static {
+        foo()
+        ;bar()
+    }
+}
 ```
 
 ## When Not To Use It
diff --git a/docs/rules/semi.md b/docs/rules/semi.md
index 158cd7f53..cb8e6dd0d 100644
--- a/docs/rules/semi.md
+++ b/docs/rules/semi.md
@@ -172,6 +172,14 @@ Examples of additional **correct** code for this rule with the `"always", { "omi
 if (foo) { bar() }
 
 if (foo) { bar(); baz() }
+
+function f() { bar(); baz() }
+
+class C {
+    foo() { bar(); baz() }
+
+    static { bar(); baz() }
+}
 ```
 
 #### beforeStatementContinuationChars
diff --git a/docs/rules/space-before-blocks.md b/docs/rules/space-before-blocks.md
index 83e9b3d6a..35a4c16c3 100644
--- a/docs/rules/space-before-blocks.md
+++ b/docs/rules/space-before-blocks.md
@@ -63,6 +63,9 @@ if (a) {
     c();
 }
 
+class C {
+    static{} /*no error. this is checked by `keyword-spacing` rule.*/
+}
 
 function a() {}
 
diff --git a/docs/rules/strict.md b/docs/rules/strict.md
index a6d87c20a..97285afc0 100644
--- a/docs/rules/strict.md
+++ b/docs/rules/strict.md
@@ -49,6 +49,8 @@ This rule disallows strict mode directives, no matter which option is specified,
 
 This rule disallows strict mode directives, no matter which option is specified, in functions with non-simple parameter lists (for example, parameter lists with default parameter values) because that is a syntax error in **ECMAScript 2016** and later. See the examples of the [function](#function) option.
 
+This rule does not apply to class static blocks, no matter which option is specified, because class static blocks do not have directives. Therefore, a `"use strict"` statement in a class static block is not a directive, and will be reported by the [no-unused-expressions](no-unused-expressions.md) rule.
+
 The `--fix` option on the command line does not insert new `"use strict"` statements, but only removes unneeded statements.
 
 ## Options
diff --git a/docs/user-guide/command-line-interface.md b/docs/user-guide/command-line-interface.md
index 9ee7df474..ad84c37b6 100644
--- a/docs/user-guide/command-line-interface.md
+++ b/docs/user-guide/command-line-interface.md
@@ -473,7 +473,8 @@ This option causes ESLint to exit with exit code 2 if one or more fatal parsing
 
 #### `--debug`
 
-This option outputs debugging information to the console. This information is useful when you're seeing a problem and having a hard time pinpointing it. The ESLint team may ask for this debugging information to help solve bugs.
+This option outputs debugging information to the console. This information is useful when you're seeing a problem and having a hard time pinpointing it. The ESLint team may ask for this debugging information to help solve bugs.  
+Add this flag to an ESLint command line invocation in order to get extra debug information as the command is run (e.g. `eslint --debug test.js` and `eslint test.js --debug` are equivalent)
 
 #### `-h`, `--help`
 
diff --git a/lib/linter/code-path-analysis/code-path-analyzer.js b/lib/linter/code-path-analysis/code-path-analyzer.js
index d66c2f1be..2dcc27348 100644
--- a/lib/linter/code-path-analysis/code-path-analyzer.js
+++ b/lib/linter/code-path-analysis/code-path-analyzer.js
@@ -461,6 +461,10 @@ function processCodePathToEnter(analyzer, node) {
             startCodePath("function");
             break;
 
+        case "StaticBlock":
+            startCodePath("class-static-block");
+            break;
+
         case "ChainExpression":
             state.pushChainContext();
             break;
@@ -706,7 +710,8 @@ function postprocess(analyzer, node) {
         case "Program":
         case "FunctionDeclaration":
         case "FunctionExpression":
-        case "ArrowFunctionExpression": {
+        case "ArrowFunctionExpression":
+        case "StaticBlock": {
             endCodePath();
             break;
         }
diff --git a/lib/linter/code-path-analysis/code-path.js b/lib/linter/code-path-analysis/code-path.js
index f225c09a1..0e6662770 100644
--- a/lib/linter/code-path-analysis/code-path.js
+++ b/lib/linter/code-path-analysis/code-path.js
@@ -40,7 +40,7 @@ class CodePath {
 
         /**
          * The reason that this code path was started. May be "program",
-         * "function", or "class-field-initializer".
+         * "function", "class-field-initializer", or "class-static-block".
          * @type {string}
          */
         this.origin = origin;
diff --git a/lib/rules/block-spacing.js b/lib/rules/block-spacing.js
index 13cfbf0e2..990b441e3 100644
--- a/lib/rules/block-spacing.js
+++ b/lib/rules/block-spacing.js
@@ -40,7 +40,7 @@ module.exports = {
 
         /**
          * Gets the open brace token from a given node.
-         * @param {ASTNode} node A BlockStatement/SwitchStatement node to get.
+         * @param {ASTNode} node A BlockStatement/StaticBlock/SwitchStatement node to get.
          * @returns {Token} The token of the open brace.
          */
         function getOpenBrace(node) {
@@ -50,6 +50,12 @@ module.exports = {
                 }
                 return sourceCode.getLastToken(node, 1);
             }
+
+            if (node.type === "StaticBlock") {
+                return sourceCode.getFirstToken(node, { skip: 1 }); // skip the `static` token
+            }
+
+            // "BlockStatement"
             return sourceCode.getFirstToken(node);
         }
 
@@ -72,8 +78,8 @@ module.exports = {
         }
 
         /**
-         * Reports invalid spacing style inside braces.
-         * @param {ASTNode} node A BlockStatement/SwitchStatement node to get.
+         * Checks and reports invalid spacing style inside braces.
+         * @param {ASTNode} node A BlockStatement/StaticBlock/SwitchStatement node to check.
          * @returns {void}
          */
         function checkSpacingInsideBraces(node) {
@@ -157,6 +163,7 @@ module.exports = {
 
         return {
             BlockStatement: checkSpacingInsideBraces,
+            StaticBlock: checkSpacingInsideBraces,
             SwitchStatement: checkSpacingInsideBraces
         };
     }
diff --git a/lib/rules/brace-style.js b/lib/rules/brace-style.js
index 60aa53269..89f9ba559 100644
--- a/lib/rules/brace-style.js
+++ b/lib/rules/brace-style.js
@@ -155,6 +155,12 @@ module.exports = {
                     validateCurlyPair(sourceCode.getFirstToken(node), sourceCode.getLastToken(node));
                 }
             },
+            StaticBlock(node) {
+                validateCurlyPair(
+                    sourceCode.getFirstToken(node, { skip: 1 }), // skip the `static` token
+                    sourceCode.getLastToken(node)
+                );
+            },
             ClassBody(node) {
                 validateCurlyPair(sourceCode.getFirstToken(node), sourceCode.getLastToken(node));
             },
diff --git a/lib/rules/class-methods-use-this.js b/lib/rules/class-methods-use-this.js
index 034ba3abc..beb742d93 100644
--- a/lib/rules/class-methods-use-this.js
+++ b/lib/rules/class-methods-use-this.js
@@ -161,8 +161,17 @@ module.exports = {
             /*
              * Class field value are implicit functions.
              */
-            "PropertyDefinition:exit": popContext,
             "PropertyDefinition > *.key:exit": pushContext,
+            "PropertyDefinition:exit": popContext,
+
+            /*
+             * Class static blocks are implicit functions. They aren't required to use `this`,
+             * but we have to push context so that it captures any use of `this` in the static block
+             * separately from enclosing contexts, because static blocks have their own `this` and it
+             * shouldn't count as used `this` in enclosing contexts.
+             */
+            StaticBlock: pushContext,
+            "StaticBlock:exit": popContext,
 
             ThisExpression: markThisUsed,
             Super: markThisUsed,
diff --git a/lib/rules/complexity.js b/lib/rules/complexity.js
index b833aafc0..a24703976 100644
--- a/lib/rules/complexity.js
+++ b/lib/rules/complexity.js
@@ -124,20 +124,28 @@ module.exports = {
 
                 /*
                  * This rule only evaluates complexity of functions, so "program" is excluded.
-                 * Class field initializers are implicit functions. Therefore, they shouldn't contribute
-                 * to the enclosing function's complexity, but their own complexity should be evaluated.
+                 * Class field initializers and class static blocks are implicit functions. Therefore,
+                 * they shouldn't contribute to the enclosing function's complexity, but their
+                 * own complexity should be evaluated.
                  */
                 if (
                     codePath.origin !== "function" &&
-                    codePath.origin !== "class-field-initializer"
+                    codePath.origin !== "class-field-initializer" &&
+                    codePath.origin !== "class-static-block"
                 ) {
                     return;
                 }
 
                 if (complexity > THRESHOLD) {
-                    const name = codePath.origin === "class-field-initializer"
-                        ? "class field initializer"
-                        : astUtils.getFunctionNameWithKind(node);
+                    let name;
+
+                    if (codePath.origin === "class-field-initializer") {
+                        name = "class field initializer";
+                    } else if (codePath.origin === "class-static-block") {
+                        name = "class static block";
+                    } else {
+                        name = astUtils.getFunctionNameWithKind(node);
+                    }
 
                     context.report({
                         node,
diff --git a/lib/rules/indent.js b/lib/rules/indent.js
index 7b17e3e54..f4dbfff27 100644
--- a/lib/rules/indent.js
+++ b/lib/rules/indent.js
@@ -68,6 +68,7 @@ const KNOWN_NODES = new Set([
     "ReturnStatement",
     "SequenceExpression",
     "SpreadElement",
+    "StaticBlock",
     "Super",
     "SwitchCase",
     "SwitchStatement",
@@ -583,6 +584,16 @@ module.exports = {
                         },
                         additionalProperties: false
                     },
+                    StaticBlock: {
+                        type: "object",
+                        properties: {
+                            body: {
+                                type: "integer",
+                                minimum: 0
+                            }
+                        },
+                        additionalProperties: false
+                    },
                     CallExpression: {
                         type: "object",
                         properties: {
@@ -646,6 +657,9 @@ module.exports = {
                 parameters: DEFAULT_PARAMETER_INDENT,
                 body: DEFAULT_FUNCTION_BODY_INDENT
             },
+            StaticBlock: {
+                body: DEFAULT_FUNCTION_BODY_INDENT
+            },
             CallExpression: {
                 arguments: DEFAULT_PARAMETER_INDENT
             },
@@ -1397,6 +1411,13 @@ module.exports = {
                 }
             },
 
+            StaticBlock(node) {
+                const openingCurly = sourceCode.getFirstToken(node, { skip: 1 }); // skip the `static` token
+                const closingCurly = sourceCode.getLastToken(node);
+
+                addElementListIndent(node.body, openingCurly, closingCurly, options.StaticBlock.body);
+            },
+
             SwitchStatement(node) {
                 const openingCurly = sourceCode.getTokenAfter(node.discriminant, astUtils.isOpeningBraceToken);
                 const closingCurly = sourceCode.getLastToken(node);
diff --git a/lib/rules/keyword-spacing.js b/lib/rules/keyword-spacing.js
index d860ae0f0..44222e1a4 100644
--- a/lib/rules/keyword-spacing.js
+++ b/lib/rules/keyword-spacing.js
@@ -590,6 +590,7 @@ module.exports = {
             ImportNamespaceSpecifier: checkSpacingForImportNamespaceSpecifier,
             MethodDefinition: checkSpacingForProperty,
             PropertyDefinition: checkSpacingForProperty,
+            StaticBlock: checkSpacingAroundFirstToken,
             Property: checkSpacingForProperty,
 
             // To avoid conflicts with `space-infix-ops`, e.g. `a > this.b`
diff --git a/lib/rules/lines-around-comment.js b/lib/rules/lines-around-comment.js
index 79bcbb7fc..513d19622 100644
--- a/lib/rules/lines-around-comment.js
+++ b/lib/rules/lines-around-comment.js
@@ -185,10 +185,39 @@ module.exports = {
         /**
          * Returns the parent node that contains the given token.
          * @param {token} token The token to check.
-         * @returns {ASTNode} The parent node that contains the given token.
+         * @returns {ASTNode|null} The parent node that contains the given token.
          */
         function getParentNodeOfToken(token) {
-            return sourceCode.getNodeByRangeIndex(token.range[0]);
+            const node = sourceCode.getNodeByRangeIndex(token.range[0]);
+
+            /*
+             * For the purpose of this rule, the comment token is in a `StaticBlock` node only
+             * if it's inside the braces of that `StaticBlock` node.
+             *
+             * Example where this function returns `null`:
+             *
+             *   static
+             *   // comment
+             *   {
+             *   }
+             *
+             * Example where this function returns `StaticBlock` node:
+             *
+             *   static
+             *   {
+             *   // comment
+             *   }
+             *
+             */
+            if (node && node.type === "StaticBlock") {
+                const openingBrace = sourceCode.getFirstToken(node, { skip: 1 }); // skip the `static` token
+
+                return token.range[0] >= openingBrace.range[0]
+                    ? node
+                    : null;
+            }
+
+            return node;
         }
 
         /**
@@ -200,8 +229,15 @@ module.exports = {
         function isCommentAtParentStart(token, nodeType) {
             const parent = getParentNodeOfToken(token);
 
-            return parent && isParentNodeType(parent, nodeType) &&
-                    token.loc.start.line - parent.loc.start.line === 1;
+            if (parent && isParentNodeType(parent, nodeType)) {
+                const parentStartNodeOrToken = parent.type === "StaticBlock"
+                    ? sourceCode.getFirstToken(parent, { skip: 1 }) // opening brace of the static block
+                    : parent;
+
+                return token.loc.start.line - parentStartNodeOrToken.loc.start.line === 1;
+            }
+
+            return false;
         }
 
         /**
@@ -213,7 +249,7 @@ module.exports = {
         function isCommentAtParentEnd(token, nodeType) {
             const parent = getParentNodeOfToken(token);
 
-            return parent && isParentNodeType(parent, nodeType) &&
+            return !!parent && isParentNodeType(parent, nodeType) &&
                     parent.loc.end.line - token.loc.end.line === 1;
         }
 
@@ -223,7 +259,12 @@ module.exports = {
          * @returns {boolean} True if the comment is at block start.
          */
         function isCommentAtBlockStart(token) {
-            return isCommentAtParentStart(token, "ClassBody") || isCommentAtParentStart(token, "BlockStatement") || isCommentAtParentStart(token, "SwitchCase");
+            return (
+                isCommentAtParentStart(token, "ClassBody") ||
+                isCommentAtParentStart(token, "BlockStatement") ||
+                isCommentAtParentStart(token, "StaticBlock") ||
+                isCommentAtParentStart(token, "SwitchCase")
+            );
         }
 
         /**
@@ -232,7 +273,13 @@ module.exports = {
          * @returns {boolean} True if the comment is at block end.
          */
         function isCommentAtBlockEnd(token) {
-            return isCommentAtParentEnd(token, "ClassBody") || isCommentAtParentEnd(token, "BlockStatement") || isCommentAtParentEnd(token, "SwitchCase") || isCommentAtParentEnd(token, "SwitchStatement");
+            return (
+                isCommentAtParentEnd(token, "ClassBody") ||
+                isCommentAtParentEnd(token, "BlockStatement") ||
+                isCommentAtParentEnd(token, "StaticBlock") ||
+                isCommentAtParentEnd(token, "SwitchCase") ||
+                isCommentAtParentEnd(token, "SwitchStatement")
+            );
         }
 
         /**
diff --git a/lib/rules/max-depth.js b/lib/rules/max-depth.js
index 415598b29..bdacc66af 100644
--- a/lib/rules/max-depth.js
+++ b/lib/rules/max-depth.js
@@ -118,6 +118,7 @@ module.exports = {
             FunctionDeclaration: startFunction,
             FunctionExpression: startFunction,
             ArrowFunctionExpression: startFunction,
+            StaticBlock: startFunction,
 
             IfStatement(node) {
                 if (node.parent.type !== "IfStatement") {
@@ -146,6 +147,7 @@ module.exports = {
             "FunctionDeclaration:exit": endFunction,
             "FunctionExpression:exit": endFunction,
             "ArrowFunctionExpression:exit": endFunction,
+            "StaticBlock:exit": endFunction,
             "Program:exit": endFunction
         };
 
diff --git a/lib/rules/max-statements.js b/lib/rules/max-statements.js
index 6f48c9218..969e40bbd 100644
--- a/lib/rules/max-statements.js
+++ b/lib/rules/max-statements.js
@@ -123,6 +123,14 @@ module.exports = {
         function endFunction(node) {
             const count = functionStack.pop();
 
+            /*
+             * This rule does not apply to class static blocks, but we have to track them so
+             * that stataments in them do not count as statements in the enclosing function.
+             */
+            if (node.type === "StaticBlock") {
+                return;
+            }
+
             if (ignoreTopLevelFunctions && functionStack.length === 0) {
                 topLevelFunctions.push({ node, count });
             } else {
@@ -148,12 +156,14 @@ module.exports = {
             FunctionDeclaration: startFunction,
             FunctionExpression: startFunction,
             ArrowFunctionExpression: startFunction,
+            StaticBlock: startFunction,
 
             BlockStatement: countStatements,
 
             "FunctionDeclaration:exit": endFunction,
             "FunctionExpression:exit": endFunction,
             "ArrowFunctionExpression:exit": endFunction,
+            "StaticBlock:exit": endFunction,
 
             "Program:exit"() {
                 if (topLevelFunctions.length === 1) {
diff --git a/lib/rules/no-eval.js b/lib/rules/no-eval.js
index 974815283..96b85a071 100644
--- a/lib/rules/no-eval.js
+++ b/lib/rules/no-eval.js
@@ -248,6 +248,8 @@ module.exports = {
             "ArrowFunctionExpression:exit": exitVarScope,
             "PropertyDefinition > *.value": enterVarScope,
             "PropertyDefinition > *.value:exit": exitVarScope,
+            StaticBlock: enterVarScope,
+            "StaticBlock:exit": exitVarScope,
 
             ThisExpression(node) {
                 if (!isMember(node.parent, "eval")) {
diff --git a/lib/rules/no-extra-semi.js b/lib/rules/no-extra-semi.js
index 952869c3e..0e2bcaf07 100644
--- a/lib/rules/no-extra-semi.js
+++ b/lib/rules/no-extra-semi.js
@@ -116,7 +116,7 @@ module.exports = {
              * @param {Node} node A MethodDefinition node of the start point.
              * @returns {void}
              */
-            "MethodDefinition, PropertyDefinition"(node) {
+            "MethodDefinition, PropertyDefinition, StaticBlock"(node) {
                 checkForPartOfClassBody(sourceCode.getTokenAfter(node));
             }
         };
diff --git a/lib/rules/no-inner-declarations.js b/lib/rules/no-inner-declarations.js
index 9bbe24d7c..49b5114a2 100644
--- a/lib/rules/no-inner-declarations.js
+++ b/lib/rules/no-inner-declarations.js
@@ -15,9 +15,33 @@ const astUtils = require("./utils/ast-utils");
 // Rule Definition
 //------------------------------------------------------------------------------
 
-const validParent = new Set(["Program", "ExportNamedDeclaration", "ExportDefaultDeclaration"]);
+const validParent = new Set(["Program", "StaticBlock", "ExportNamedDeclaration", "ExportDefaultDeclaration"]);
 const validBlockStatementParent = new Set(["FunctionDeclaration", "FunctionExpression", "ArrowFunctionExpression"]);
 
+/**
+ * Finds the nearest enclosing context where this rule allows declarations and returns its description.
+ * @param {ASTNode} node Node to search from.
+ * @returns {string} Description. One of "program", "function body", "class static block body".
+ */
+function getAllowedBodyDescription(node) {
+    let { parent } = node;
+
+    while (parent) {
+
+        if (parent.type === "StaticBlock") {
+            return "class static block body";
+        }
+
+        if (astUtils.isFunction(parent)) {
+            return "function body";
+        }
+
+        ({ parent } = parent);
+    }
+
+    return "program";
+}
+
 module.exports = {
     meta: {
         type: "problem",
@@ -59,14 +83,12 @@ module.exports = {
                 return;
             }
 
-            const upperFunction = astUtils.getUpperFunction(parent);
-
             context.report({
                 node,
                 messageId: "moveDeclToRoot",
                 data: {
                     type: (node.type === "FunctionDeclaration" ? "function" : "variable"),
-                    body: (upperFunction === null ? "program" : "function body")
+                    body: getAllowedBodyDescription(node)
                 }
             });
         }
diff --git a/lib/rules/no-invalid-this.js b/lib/rules/no-invalid-this.js
index 77558b90d..e1d7cbcf5 100644
--- a/lib/rules/no-invalid-this.js
+++ b/lib/rules/no-invalid-this.js
@@ -132,6 +132,10 @@ module.exports = {
             "PropertyDefinition > *.value": enterFunction,
             "PropertyDefinition > *.value:exit": exitFunction,
 
+            // Class static blocks are implicit functions.
+            StaticBlock: enterFunction,
+            "StaticBlock:exit": exitFunction,
+
             // Reports if `this` of the current context is invalid.
             ThisExpression(node) {
                 const current = stack.getCurrent();
diff --git a/lib/rules/no-lone-blocks.js b/lib/rules/no-lone-blocks.js
index 5f74cd83c..33d4706a9 100644
--- a/lib/rules/no-lone-blocks.js
+++ b/lib/rules/no-lone-blocks.js
@@ -39,7 +39,9 @@ module.exports = {
          * @returns {void}
          */
         function report(node) {
-            const messageId = node.parent.type === "BlockStatement" ? "redundantNestedBlock" : "redundantBlock";
+            const messageId = node.parent.type === "BlockStatement" || node.parent.type === "StaticBlock"
+                ? "redundantNestedBlock"
+                : "redundantBlock";
 
             context.report({
                 node,
@@ -54,6 +56,7 @@ module.exports = {
          */
         function isLoneBlock(node) {
             return node.parent.type === "BlockStatement" ||
+                node.parent.type === "StaticBlock" ||
                 node.parent.type === "Program" ||
 
                 // Don't report blocks in switch cases if the block is the only statement of the case.
@@ -99,7 +102,10 @@ module.exports = {
                         loneBlocks.pop();
                         report(node);
                     } else if (
-                        node.parent.type === "BlockStatement" &&
+                        (
+                            node.parent.type === "BlockStatement" ||
+                            node.parent.type === "StaticBlock"
+                        ) &&
                         node.parent.body.length === 1
                     ) {
                         report(node);
diff --git a/lib/rules/no-redeclare.js b/lib/rules/no-redeclare.js
index afbe6170c..3de4397b1 100644
--- a/lib/rules/no-redeclare.js
+++ b/lib/rules/no-redeclare.js
@@ -161,6 +161,8 @@ module.exports = {
             FunctionExpression: checkForBlock,
             ArrowFunctionExpression: checkForBlock,
 
+            StaticBlock: checkForBlock,
+
             BlockStatement: checkForBlock,
             ForStatement: checkForBlock,
             ForInStatement: checkForBlock,
diff --git a/lib/rules/one-var.js b/lib/rules/one-var.js
index 9c78ef87d..daff2d22b 100644
--- a/lib/rules/one-var.js
+++ b/lib/rules/one-var.js
@@ -541,6 +541,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 +554,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
         };
 
     }
diff --git a/lib/rules/padded-blocks.js b/lib/rules/padded-blocks.js
index ca83f11fc..de75e8d2d 100644
--- a/lib/rules/padded-blocks.js
+++ b/lib/rules/padded-blocks.js
@@ -106,6 +106,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 +178,7 @@ module.exports = {
         function requirePaddingFor(node) {
             switch (node.type) {
                 case "BlockStatement":
+                case "StaticBlock":
                     return options.blocks;
                 case "SwitchStatement":
                     return options.switches;
@@ -282,6 +289,7 @@ module.exports = {
                 }
                 checkPadding(node);
             };
+            rule.StaticBlock = rule.BlockStatement;
         }
 
         if (Object.prototype.hasOwnProperty.call(options, "classes")) {
diff --git a/lib/rules/padding-line-between-statements.js b/lib/rules/padding-line-between-statements.js
index 073940a40..42859dd38 100644
--- a/lib/rules/padding-line-between-statements.js
+++ b/lib/rules/padding-line-between-statements.js
@@ -618,9 +618,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,
 
diff --git a/lib/rules/prefer-const.js b/lib/rules/prefer-const.js
index b44bd7592..38ec973fc 100644
--- a/lib/rules/prefer-const.js
+++ b/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;
 
 /**
diff --git a/lib/rules/semi-style.js b/lib/rules/semi-style.js
index 43d8d51f9..2d17d028c 100644
--- a/lib/rules/semi-style.js
+++ b/lib/rules/semi-style.js
@@ -25,7 +25,8 @@ const SELECTOR = [
 
 /**
  * Get the child node list of a given node.
- * This returns `Program#body`, `BlockStatement#body`, or `SwitchCase#consequent`.
+ * This returns `BlockStatement#body`, `StaticBlock#body`, `Program#body`,
+ * `ClassBody#body`, or `SwitchCase#consequent`.
  * This is used to check whether a node is the first/last child.
  * @param {Node} node A node to get child node list.
  * @returns {Node[]|null} The child node list.
@@ -33,7 +34,12 @@ const SELECTOR = [
 function getChildren(node) {
     const t = node.type;
 
-    if (t === "BlockStatement" || t === "Program" || t === "ClassBody") {
+    if (
+        t === "BlockStatement" ||
+        t === "StaticBlock" ||
+        t === "Program" ||
+        t === "ClassBody"
+    ) {
         return node.body;
     }
     if (t === "SwitchCase") {
diff --git a/lib/rules/semi.js b/lib/rules/semi.js
index 4124a8c50..c29029ced 100644
--- a/lib/rules/semi.js
+++ b/lib/rules/semi.js
@@ -306,22 +306,31 @@ module.exports = {
         }
 
         /**
-         * Checks a node to see if it's in a one-liner block statement.
+         * Checks a node to see if it's the last item in a one-liner block.
+         * Block is any `BlockStatement` or `StaticBlock` node. Block is a one-liner if its
+         * braces (and consequently everything between them) are on the same line.
          * @param {ASTNode} node The node to check.
-         * @returns {boolean} whether the node is in a one-liner block statement.
+         * @returns {boolean} whether the node is the last item in a one-liner block.
          */
-        function isOneLinerBlock(node) {
+        function isLastInOneLinerBlock(node) {
             const parent = node.parent;
             const nextToken = sourceCode.getTokenAfter(node);
 
             if (!nextToken || nextToken.value !== "}") {
                 return false;
             }
-            return (
-                !!parent &&
-                parent.type === "BlockStatement" &&
-                parent.loc.start.line === parent.loc.end.line
-            );
+
+            if (parent.type === "BlockStatement") {
+                return parent.loc.start.line === parent.loc.end.line;
+            }
+
+            if (parent.type === "StaticBlock") {
+                const openingBrace = sourceCode.getFirstToken(parent, { skip: 1 }); // skip the `static` token
+
+                return openingBrace.loc.start.line === parent.loc.end.line;
+            }
+
+            return false;
         }
 
         /**
@@ -343,7 +352,7 @@ module.exports = {
                     report(node);
                 }
             } else {
-                const oneLinerBlock = (exceptOneLine && isOneLinerBlock(node));
+                const oneLinerBlock = (exceptOneLine && isLastInOneLinerBlock(node));
 
                 if (isSemi && oneLinerBlock) {
                     report(node, true);
diff --git a/lib/rules/utils/ast-utils.js b/lib/rules/utils/ast-utils.js
index e4fd977c1..16d7b8115 100644
--- a/lib/rules/utils/ast-utils.js
+++ b/lib/rules/utils/ast-utils.js
@@ -35,7 +35,7 @@ const COMMENTS_IGNORE_PATTERN = /^\s*(?:eslint|jshint\s+|jslint\s+|istanbul\s+|g
 const LINEBREAKS = new Set(["\r\n", "\r", "\n", "\u2028", "\u2029"]);
 
 // A set of node types that can contain a list of statements
-const STATEMENT_LIST_PARENTS = new Set(["Program", "BlockStatement", "SwitchCase"]);
+const STATEMENT_LIST_PARENTS = new Set(["Program", "BlockStatement", "StaticBlock", "SwitchCase"]);
 
 const DECIMAL_INTEGER_PATTERN = /^(?:0|0[0-7]*[89]\d*|[1-9](?:_?\d)*)$/u;
 
@@ -937,6 +937,8 @@ module.exports = {
      *
      * First, this checks the node:
      *
+     * - The given node is not in `PropertyDefinition#value` position.
+     * - The given node is not `StaticBlock`.
      * - The function name does not start with uppercase. It's a convention to capitalize the names
      *   of constructor functions. This check is not performed if `capIsConstructor` is set to `false`.
      * - The function does not have a JSDoc comment that has a @this tag.
@@ -951,7 +953,8 @@ module.exports = {
      * - The location is not on an ES2015 class.
      * - Its `bind`/`call`/`apply` method is not called directly.
      * - The function is not a callback of array methods (such as `.forEach()`) if `thisArg` is given.
-     * @param {ASTNode} node A function node to check.
+     * @param {ASTNode} node A function node to check. It also can be an implicit function, like `StaticBlock`
+     * or any expression that is `PropertyDefinition#value` node.
      * @param {SourceCode} sourceCode A SourceCode instance to get comments.
      * @param {boolean} [capIsConstructor = true] `false` disables the assumption that functions which name starts
      * with an uppercase or are assigned to a variable which name starts with an uppercase are constructors.
@@ -964,7 +967,12 @@ module.exports = {
          * Therefore, A expression node at `PropertyDefinition#value` is a function.
          * In this case, `this` is always not default binding.
          */
-        if (node && node.parent && node.parent.type === "PropertyDefinition" && node.value === node) {
+        if (node.parent.type === "PropertyDefinition" && node.parent.value === node) {
+            return false;
+        }
+
+        // Class static blocks are implicit functions. In this case, `this` is always not default binding.
+        if (node.type === "StaticBlock") {
             return false;
         }
 
@@ -1825,6 +1833,10 @@ module.exports = {
             return true;
         }
 
+        if (rightToken.type === "PrivateIdentifier") {
+            return true;
+        }
+
         return false;
     },
 
diff --git a/package.json b/package.json
index 1b5558976..e36330582 100644
--- a/package.json
+++ b/package.json
@@ -56,10 +56,10 @@
     "doctrine": "^3.0.0",
     "enquirer": "^2.3.5",
     "escape-string-regexp": "^4.0.0",
-    "eslint-scope": "^6.0.0",
+    "eslint-scope": "^7.1.0",
     "eslint-utils": "^3.0.0",
     "eslint-visitor-keys": "^3.1.0",
-    "espree": "^9.0.0",
+    "espree": "^9.1.0",
     "esquery": "^1.4.0",
     "esutils": "^2.0.2",
     "fast-deep-equal": "^3.1.3",


Test patch:
diff --git a/tests/fixtures/code-path-analysis/class-static-blocks--between-fields.js b/tests/fixtures/code-path-analysis/class-static-blocks--between-fields.js
new file mode 100644
index 000000000..9bf8edfef
--- /dev/null
+++ b/tests/fixtures/code-path-analysis/class-static-blocks--between-fields.js
@@ -0,0 +1,65 @@
+/*expected
+initial->s2_1->s2_2->s2_3;
+s2_1->s2_3->final;
+*/
+/*expected
+initial->s3_1->s3_2->s3_3->s3_4;
+s3_1->s3_4;
+s3_2->s3_4->final;
+*/
+/*expected
+initial->s4_1->s4_2->s4_3->s4_4->s4_5;
+s4_1->s4_5;
+s4_2->s4_5;
+s4_3->s4_5->final;
+*/
+/*expected
+initial->s1_1->final;
+*/
+class Foo { bar = a || b; static { x || y || z } baz = p || q || r || s; }
+
+/*DOT
+digraph {
+    node[shape=box,style="rounded,filled",fillcolor=white];
+    initial[label="",shape=circle,style=filled,fillcolor=black,width=0.25,height=0.25];
+    final[label="",shape=doublecircle,style=filled,fillcolor=black,width=0.25,height=0.25];
+    s2_1[label="LogicalExpression:enter\nIdentifier (a)"];
+    s2_2[label="Identifier (b)"];
+    s2_3[label="LogicalExpression:exit"];
+    initial->s2_1->s2_2->s2_3;
+    s2_1->s2_3->final;
+}
+digraph {
+    node[shape=box,style="rounded,filled",fillcolor=white];
+    initial[label="",shape=circle,style=filled,fillcolor=black,width=0.25,height=0.25];
+    final[label="",shape=doublecircle,style=filled,fillcolor=black,width=0.25,height=0.25];
+    s3_1[label="StaticBlock:enter\nExpressionStatement:enter\nLogicalExpression:enter\nLogicalExpression:enter\nIdentifier (x)"];
+    s3_2[label="Identifier (y)\nLogicalExpression:exit"];
+    s3_3[label="Identifier (z)"];
+    s3_4[label="LogicalExpression:exit\nExpressionStatement:exit\nStaticBlock:exit"];
+    initial->s3_1->s3_2->s3_3->s3_4;
+    s3_1->s3_4;
+    s3_2->s3_4->final;
+}
+digraph {
+    node[shape=box,style="rounded,filled",fillcolor=white];
+    initial[label="",shape=circle,style=filled,fillcolor=black,width=0.25,height=0.25];
+    final[label="",shape=doublecircle,style=filled,fillcolor=black,width=0.25,height=0.25];
+    s4_1[label="LogicalExpression:enter\nLogicalExpression:enter\nLogicalExpression:enter\nIdentifier (p)"];
+    s4_2[label="Identifier (q)\nLogicalExpression:exit"];
+    s4_3[label="Identifier (r)\nLogicalExpression:exit"];
+    s4_4[label="Identifier (s)"];
+    s4_5[label="LogicalExpression:exit"];
+    initial->s4_1->s4_2->s4_3->s4_4->s4_5;
+    s4_1->s4_5;
+    s4_2->s4_5;
+    s4_3->s4_5->final;
+}
+digraph {
+    node[shape=box,style="rounded,filled",fillcolor=white];
+    initial[label="",shape=circle,style=filled,fillcolor=black,width=0.25,height=0.25];
+    final[label="",shape=doublecircle,style=filled,fillcolor=black,width=0.25,height=0.25];
+    s1_1[label="Program:enter\nClassDeclaration:enter\nIdentifier (Foo)\nClassBody:enter\nPropertyDefinition:enter\nIdentifier (bar)\nLogicalExpression\nPropertyDefinition:exit\nStaticBlock\nPropertyDefinition:enter\nIdentifier (baz)\nLogicalExpression\nPropertyDefinition:exit\nClassBody:exit\nClassDeclaration:exit\nProgram:exit"];
+    initial->s1_1->final;
+}
+*/
diff --git a/tests/fixtures/code-path-analysis/class-static-blocks--between-methods.js b/tests/fixtures/code-path-analysis/class-static-blocks--between-methods.js
new file mode 100644
index 000000000..a6de6909a
--- /dev/null
+++ b/tests/fixtures/code-path-analysis/class-static-blocks--between-methods.js
@@ -0,0 +1,65 @@
+/*expected
+initial->s2_1->s2_2->s2_3;
+s2_1->s2_3->final;
+*/
+/*expected
+initial->s3_1->s3_2->s3_3->s3_4;
+s3_1->s3_4;
+s3_2->s3_4->final;
+*/
+/*expected
+initial->s4_1->s4_2->s4_3->s4_4->s4_5;
+s4_1->s4_5;
+s4_2->s4_5;
+s4_3->s4_5->final;
+*/
+/*expected
+initial->s1_1->final;
+*/
+class Foo { bar () { a || b } static { x || y || z } baz() { p || q || r || s } }
+
+/*DOT
+digraph {
+    node[shape=box,style="rounded,filled",fillcolor=white];
+    initial[label="",shape=circle,style=filled,fillcolor=black,width=0.25,height=0.25];
+    final[label="",shape=doublecircle,style=filled,fillcolor=black,width=0.25,height=0.25];
+    s2_1[label="FunctionExpression:enter\nBlockStatement:enter\nExpressionStatement:enter\nLogicalExpression:enter\nIdentifier (a)"];
+    s2_2[label="Identifier (b)"];
+    s2_3[label="LogicalExpression:exit\nExpressionStatement:exit\nBlockStatement:exit\nFunctionExpression:exit"];
+    initial->s2_1->s2_2->s2_3;
+    s2_1->s2_3->final;
+}
+digraph {
+    node[shape=box,style="rounded,filled",fillcolor=white];
+    initial[label="",shape=circle,style=filled,fillcolor=black,width=0.25,height=0.25];
+    final[label="",shape=doublecircle,style=filled,fillcolor=black,width=0.25,height=0.25];
+    s3_1[label="StaticBlock:enter\nExpressionStatement:enter\nLogicalExpression:enter\nLogicalExpression:enter\nIdentifier (x)"];
+    s3_2[label="Identifier (y)\nLogicalExpression:exit"];
+    s3_3[label="Identifier (z)"];
+    s3_4[label="LogicalExpression:exit\nExpressionStatement:exit\nStaticBlock:exit"];
+    initial->s3_1->s3_2->s3_3->s3_4;
+    s3_1->s3_4;
+    s3_2->s3_4->final;
+}
+digraph {
+    node[shape=box,style="rounded,filled",fillcolor=white];
+    initial[label="",shape=circle,style=filled,fillcolor=black,width=0.25,height=0.25];
+    final[label="",shape=doublecircle,style=filled,fillcolor=black,width=0.25,height=0.25];
+    s4_1[label="FunctionExpression:enter\nBlockStatement:enter\nExpressionStatement:enter\nLogicalExpression:enter\nLogicalExpression:enter\nLogicalExpression:enter\nIdentifier (p)"];
+    s4_2[label="Identifier (q)\nLogicalExpression:exit"];
+    s4_3[label="Identifier (r)\nLogicalExpression:exit"];
+    s4_4[label="Identifier (s)"];
+    s4_5[label="LogicalExpression:exit\nExpressionStatement:exit\nBlockStatement:exit\nFunctionExpression:exit"];
+    initial->s4_1->s4_2->s4_3->s4_4->s4_5;
+    s4_1->s4_5;
+    s4_2->s4_5;
+    s4_3->s4_5->final;
+}
+digraph {
+    node[shape=box,style="rounded,filled",fillcolor=white];
+    initial[label="",shape=circle,style=filled,fillcolor=black,width=0.25,height=0.25];
+    final[label="",shape=doublecircle,style=filled,fillcolor=black,width=0.25,height=0.25];
+    s1_1[label="Program:enter\nClassDeclaration:enter\nIdentifier (Foo)\nClassBody:enter\nMethodDefinition:enter\nIdentifier (bar)\nFunctionExpression\nMethodDefinition:exit\nStaticBlock\nMethodDefinition:enter\nIdentifier (baz)\nFunctionExpression\nMethodDefinition:exit\nClassBody:exit\nClassDeclaration:exit\nProgram:exit"];
+    initial->s1_1->final;
+}
+*/
diff --git a/tests/fixtures/code-path-analysis/class-static-blocks--conditional.js b/tests/fixtures/code-path-analysis/class-static-blocks--conditional.js
new file mode 100644
index 000000000..bcdb4a7ec
--- /dev/null
+++ b/tests/fixtures/code-path-analysis/class-static-blocks--conditional.js
@@ -0,0 +1,29 @@
+/*expected
+initial->s2_1->s2_2->s2_4;
+s2_1->s2_3->s2_4->final;
+*/
+/*expected
+initial->s1_1->final;
+*/
+class Foo { static { this.bar = a ? b : c; } }
+
+/*DOT
+digraph {
+    node[shape=box,style="rounded,filled",fillcolor=white];
+    initial[label="",shape=circle,style=filled,fillcolor=black,width=0.25,height=0.25];
+    final[label="",shape=doublecircle,style=filled,fillcolor=black,width=0.25,height=0.25];
+    s2_1[label="StaticBlock:enter\nExpressionStatement:enter\nAssignmentExpression:enter\nMemberExpression:enter\nThisExpression\nIdentifier (bar)\nMemberExpression:exit\nConditionalExpression:enter\nIdentifier (a)"];
+    s2_2[label="Identifier (b)"];
+    s2_4[label="ConditionalExpression:exit\nAssignmentExpression:exit\nExpressionStatement:exit\nStaticBlock:exit"];
+    s2_3[label="Identifier (c)"];
+    initial->s2_1->s2_2->s2_4;
+    s2_1->s2_3->s2_4->final;
+}
+digraph {
+    node[shape=box,style="rounded,filled",fillcolor=white];
+    initial[label="",shape=circle,style=filled,fillcolor=black,width=0.25,height=0.25];
+    final[label="",shape=doublecircle,style=filled,fillcolor=black,width=0.25,height=0.25];
+    s1_1[label="Program:enter\nClassDeclaration:enter\nIdentifier (Foo)\nClassBody:enter\nStaticBlock\nClassBody:exit\nClassDeclaration:exit\nProgram:exit"];
+    initial->s1_1->final;
+}
+*/
diff --git a/tests/fixtures/code-path-analysis/class-static-blocks--empty.js b/tests/fixtures/code-path-analysis/class-static-blocks--empty.js
new file mode 100644
index 000000000..40a1e71ae
--- /dev/null
+++ b/tests/fixtures/code-path-analysis/class-static-blocks--empty.js
@@ -0,0 +1,24 @@
+/*expected
+initial->s2_1->final;
+*/
+/*expected
+initial->s1_1->final;
+*/
+class Foo { static {} }
+
+/*DOT
+digraph {
+    node[shape=box,style="rounded,filled",fillcolor=white];
+    initial[label="",shape=circle,style=filled,fillcolor=black,width=0.25,height=0.25];
+    final[label="",shape=doublecircle,style=filled,fillcolor=black,width=0.25,height=0.25];
+    s2_1[label="StaticBlock"];
+    initial->s2_1->final;
+}
+digraph {
+    node[shape=box,style="rounded,filled",fillcolor=white];
+    initial[label="",shape=circle,style=filled,fillcolor=black,width=0.25,height=0.25];
+    final[label="",shape=doublecircle,style=filled,fillcolor=black,width=0.25,height=0.25];
+    s1_1[label="Program:enter\nClassDeclaration:enter\nIdentifier (Foo)\nClassBody:enter\nStaticBlock\nClassBody:exit\nClassDeclaration:exit\nProgram:exit"];
+    initial->s1_1->final;
+}
+*/
diff --git a/tests/fixtures/code-path-analysis/class-static-blocks--function-inside.js b/tests/fixtures/code-path-analysis/class-static-blocks--function-inside.js
new file mode 100644
index 000000000..49df347f0
--- /dev/null
+++ b/tests/fixtures/code-path-analysis/class-static-blocks--function-inside.js
@@ -0,0 +1,34 @@
+/*expected
+initial->s3_1->final;
+*/
+/*expected
+initial->s2_1->final;
+*/
+/*expected
+initial->s1_1->final;
+*/
+class Foo { static { (p) => {} } }
+
+/*DOT
+digraph {
+    node[shape=box,style="rounded,filled",fillcolor=white];
+    initial[label="",shape=circle,style=filled,fillcolor=black,width=0.25,height=0.25];
+    final[label="",shape=doublecircle,style=filled,fillcolor=black,width=0.25,height=0.25];
+    s3_1[label="ArrowFunctionExpression:enter\nIdentifier (p)\nBlockStatement\nArrowFunctionExpression:exit"];
+    initial->s3_1->final;
+}
+digraph {
+    node[shape=box,style="rounded,filled",fillcolor=white];
+    initial[label="",shape=circle,style=filled,fillcolor=black,width=0.25,height=0.25];
+    final[label="",shape=doublecircle,style=filled,fillcolor=black,width=0.25,height=0.25];
+    s2_1[label="StaticBlock:enter\nExpressionStatement:enter\nArrowFunctionExpression\nExpressionStatement:exit\nStaticBlock:exit"];
+    initial->s2_1->final;
+}
+digraph {
+    node[shape=box,style="rounded,filled",fillcolor=white];
+    initial[label="",shape=circle,style=filled,fillcolor=black,width=0.25,height=0.25];
+    final[label="",shape=doublecircle,style=filled,fillcolor=black,width=0.25,height=0.25];
+    s1_1[label="Program:enter\nClassDeclaration:enter\nIdentifier (Foo)\nClassBody:enter\nStaticBlock\nClassBody:exit\nClassDeclaration:exit\nProgram:exit"];
+    initial->s1_1->final;
+}
+*/
diff --git a/tests/fixtures/code-path-analysis/class-static-blocks--if-else.js b/tests/fixtures/code-path-analysis/class-static-blocks--if-else.js
new file mode 100644
index 000000000..7b4a542bc
--- /dev/null
+++ b/tests/fixtures/code-path-analysis/class-static-blocks--if-else.js
@@ -0,0 +1,29 @@
+/*expected
+initial->s2_1->s2_2->s2_4;
+s2_1->s2_3->s2_4->final;
+*/
+/*expected
+initial->s1_1->final;
+*/
+class Foo { static { if (bar) { this.baz = 1; } else { this.qux = 2; } } }
+
+/*DOT
+digraph {
+    node[shape=box,style="rounded,filled",fillcolor=white];
+    initial[label="",shape=circle,style=filled,fillcolor=black,width=0.25,height=0.25];
+    final[label="",shape=doublecircle,style=filled,fillcolor=black,width=0.25,height=0.25];
+    s2_1[label="StaticBlock:enter\nIfStatement:enter\nIdentifier (bar)"];
+    s2_2[label="BlockStatement:enter\nExpressionStatement:enter\nAssignmentExpression:enter\nMemberExpression:enter\nThisExpression\nIdentifier (baz)\nMemberExpression:exit\nLiteral (1)\nAssignmentExpression:exit\nExpressionStatement:exit\nBlockStatement:exit"];
+    s2_4[label="IfStatement:exit\nStaticBlock:exit"];
+    s2_3[label="BlockStatement:enter\nExpressionStatement:enter\nAssignmentExpression:enter\nMemberExpression:enter\nThisExpression\nIdentifier (qux)\nMemberExpression:exit\nLiteral (2)\nAssignmentExpression:exit\nExpressionStatement:exit\nBlockStatement:exit"];
+    initial->s2_1->s2_2->s2_4;
+    s2_1->s2_3->s2_4->final;
+}
+digraph {
+    node[shape=box,style="rounded,filled",fillcolor=white];
+    initial[label="",shape=circle,style=filled,fillcolor=black,width=0.25,height=0.25];
+    final[label="",shape=doublecircle,style=filled,fillcolor=black,width=0.25,height=0.25];
+    s1_1[label="Program:enter\nClassDeclaration:enter\nIdentifier (Foo)\nClassBody:enter\nStaticBlock\nClassBody:exit\nClassDeclaration:exit\nProgram:exit"];
+    initial->s1_1->final;
+}
+*/
diff --git a/tests/fixtures/code-path-analysis/class-static-blocks--multiple-1.js b/tests/fixtures/code-path-analysis/class-static-blocks--multiple-1.js
new file mode 100644
index 000000000..67365fb2f
--- /dev/null
+++ b/tests/fixtures/code-path-analysis/class-static-blocks--multiple-1.js
@@ -0,0 +1,34 @@
+/*expected
+initial->s2_1->final;
+*/
+/*expected
+initial->s3_1->final;
+*/
+/*expected
+initial->s1_1->final;
+*/
+class Foo { static { this.bar = 1; } static { this.baz = 2; } }
+
+/*DOT
+digraph {
+    node[shape=box,style="rounded,filled",fillcolor=white];
+    initial[label="",shape=circle,style=filled,fillcolor=black,width=0.25,height=0.25];
+    final[label="",shape=doublecircle,style=filled,fillcolor=black,width=0.25,height=0.25];
+    s2_1[label="StaticBlock:enter\nExpressionStatement:enter\nAssignmentExpression:enter\nMemberExpression:enter\nThisExpression\nIdentifier (bar)\nMemberExpression:exit\nLiteral (1)\nAssignmentExpression:exit\nExpressionStatement:exit\nStaticBlock:exit"];
+    initial->s2_1->final;
+}
+digraph {
+    node[shape=box,style="rounded,filled",fillcolor=white];
+    initial[label="",shape=circle,style=filled,fillcolor=black,width=0.25,height=0.25];
+    final[label="",shape=doublecircle,style=filled,fillcolor=black,width=0.25,height=0.25];
+    s3_1[label="StaticBlock:enter\nExpressionStatement:enter\nAssignmentExpression:enter\nMemberExpression:enter\nThisExpression\nIdentifier (baz)\nMemberExpression:exit\nLiteral (2)\nAssignmentExpression:exit\nExpressionStatement:exit\nStaticBlock:exit"];
+    initial->s3_1->final;
+}
+digraph {
+    node[shape=box,style="rounded,filled",fillcolor=white];
+    initial[label="",shape=circle,style=filled,fillcolor=black,width=0.25,height=0.25];
+    final[label="",shape=doublecircle,style=filled,fillcolor=black,width=0.25,height=0.25];
+    s1_1[label="Program:enter\nClassDeclaration:enter\nIdentifier (Foo)\nClassBody:enter\nStaticBlock\nStaticBlock\nClassBody:exit\nClassDeclaration:exit\nProgram:exit"];
+    initial->s1_1->final;
+}
+*/
diff --git a/tests/fixtures/code-path-analysis/class-static-blocks--multiple-2.js b/tests/fixtures/code-path-analysis/class-static-blocks--multiple-2.js
new file mode 100644
index 000000000..218d18a78
--- /dev/null
+++ b/tests/fixtures/code-path-analysis/class-static-blocks--multiple-2.js
@@ -0,0 +1,45 @@
+/*expected
+initial->s2_1->s2_2->s2_3->s2_4;
+s2_1->s2_4;
+s2_2->s2_4->final;
+*/
+/*expected
+initial->s3_1->s3_2->s3_3;
+s3_1->s3_3->final;
+*/
+/*expected
+initial->s1_1->final;
+*/
+class Foo { static { x || y || z } static { p || q } }
+
+/*DOT
+digraph {
+    node[shape=box,style="rounded,filled",fillcolor=white];
+    initial[label="",shape=circle,style=filled,fillcolor=black,width=0.25,height=0.25];
+    final[label="",shape=doublecircle,style=filled,fillcolor=black,width=0.25,height=0.25];
+    s2_1[label="StaticBlock:enter\nExpressionStatement:enter\nLogicalExpression:enter\nLogicalExpression:enter\nIdentifier (x)"];
+    s2_2[label="Identifier (y)\nLogicalExpression:exit"];
+    s2_3[label="Identifier (z)"];
+    s2_4[label="LogicalExpression:exit\nExpressionStatement:exit\nStaticBlock:exit"];
+    initial->s2_1->s2_2->s2_3->s2_4;
+    s2_1->s2_4;
+    s2_2->s2_4->final;
+}
+digraph {
+    node[shape=box,style="rounded,filled",fillcolor=white];
+    initial[label="",shape=circle,style=filled,fillcolor=black,width=0.25,height=0.25];
+    final[label="",shape=doublecircle,style=filled,fillcolor=black,width=0.25,height=0.25];
+    s3_1[label="StaticBlock:enter\nExpressionStatement:enter\nLogicalExpression:enter\nIdentifier (p)"];
+    s3_2[label="Identifier (q)"];
+    s3_3[label="LogicalExpression:exit\nExpressionStatement:exit\nStaticBlock:exit"];
+    initial->s3_1->s3_2->s3_3;
+    s3_1->s3_3->final;
+}
+digraph {
+    node[shape=box,style="rounded,filled",fillcolor=white];
+    initial[label="",shape=circle,style=filled,fillcolor=black,width=0.25,height=0.25];
+    final[label="",shape=doublecircle,style=filled,fillcolor=black,width=0.25,height=0.25];
+    s1_1[label="Program:enter\nClassDeclaration:enter\nIdentifier (Foo)\nClassBody:enter\nStaticBlock\nStaticBlock\nClassBody:exit\nClassDeclaration:exit\nProgram:exit"];
+    initial->s1_1->final;
+}
+*/
diff --git a/tests/fixtures/code-path-analysis/class-static-blocks--simple.js b/tests/fixtures/code-path-analysis/class-static-blocks--simple.js
new file mode 100644
index 000000000..06bb73787
--- /dev/null
+++ b/tests/fixtures/code-path-analysis/class-static-blocks--simple.js
@@ -0,0 +1,24 @@
+/*expected
+initial->s2_1->final;
+*/
+/*expected
+initial->s1_1->final;
+*/
+class Foo { static { this.bar = baz; } }
+
+/*DOT
+digraph {
+    node[shape=box,style="rounded,filled",fillcolor=white];
+    initial[label="",shape=circle,style=filled,fillcolor=black,width=0.25,height=0.25];
+    final[label="",shape=doublecircle,style=filled,fillcolor=black,width=0.25,height=0.25];
+    s2_1[label="StaticBlock:enter\nExpressionStatement:enter\nAssignmentExpression:enter\nMemberExpression:enter\nThisExpression\nIdentifier (bar)\nMemberExpression:exit\nIdentifier (baz)\nAssignmentExpression:exit\nExpressionStatement:exit\nStaticBlock:exit"];
+    initial->s2_1->final;
+}
+digraph {
+    node[shape=box,style="rounded,filled",fillcolor=white];
+    initial[label="",shape=circle,style=filled,fillcolor=black,width=0.25,height=0.25];
+    final[label="",shape=doublecircle,style=filled,fillcolor=black,width=0.25,height=0.25];
+    s1_1[label="Program:enter\nClassDeclaration:enter\nIdentifier (Foo)\nClassBody:enter\nStaticBlock\nClassBody:exit\nClassDeclaration:exit\nProgram:exit"];
+    initial->s1_1->final;
+}
+*/
diff --git a/tests/lib/linter/code-path-analysis/code-path.js b/tests/lib/linter/code-path-analysis/code-path.js
index 42a63a280..760d5b399 100644
--- a/tests/lib/linter/code-path-analysis/code-path.js
+++ b/tests/lib/linter/code-path-analysis/code-path.js
@@ -106,6 +106,12 @@ describe("CodePathAnalyzer", () => {
 
             assert.strictEqual(codePath.origin, "class-field-initializer");
         });
+
+        it("should be 'class-static-block' when code path starts inside a class static block", () => {
+            const codePath = parseCodePaths("class Foo { static { this.a=1; } }")[1];
+
+            assert.strictEqual(codePath.origin, "class-static-block");
+        });
     });
 
     describe(".traverseSegments()", () => {
diff --git a/tests/lib/rules/block-spacing.js b/tests/lib/rules/block-spacing.js
index a80d07cc7..0dfef7ed6 100644
--- a/tests/lib/rules/block-spacing.js
+++ b/tests/lib/rules/block-spacing.js
@@ -42,6 +42,9 @@ ruleTester.run("block-spacing", rule, {
         { code: "(() => { bar(); });", parserOptions: { ecmaVersion: 6 } },
         "if (a) { /* comment */ foo(); /* comment */ }",
         "if (a) { //comment\n foo(); }",
+        { code: "class C { static {} }", parserOptions: { ecmaVersion: 2022 } },
+        { code: "class C { static { foo; } }", parserOptions: { ecmaVersion: 2022 } },
+        { code: "class C { static { /* comment */foo;/* comment */ } }", parserOptions: { ecmaVersion: 2022 } },
 
         // never
         { code: "{foo();}", options: ["never"] },
@@ -62,7 +65,13 @@ ruleTester.run("block-spacing", rule, {
         { code: "(function() {bar();});", options: ["never"] },
         { code: "(() => {bar();});", options: ["never"], parserOptions: { ecmaVersion: 6 } },
         { code: "if (a) {/* comment */ foo(); /* comment */}", options: ["never"] },
-        { code: "if (a) { //comment\n foo();}", options: ["never"] }
+        { code: "if (a) { //comment\n foo();}", options: ["never"] },
+        { code: "class C { static { } }", options: ["never"], parserOptions: { ecmaVersion: 2022 } },
+        { code: "class C { static {foo;} }", options: ["never"], parserOptions: { ecmaVersion: 2022 } },
+        { code: "class C { static {/* comment */ foo; /* comment */} }", options: ["never"], parserOptions: { ecmaVersion: 2022 } },
+        { code: "class C { static { // line comment is allowed\n foo;\n} }", options: ["never"], parserOptions: { ecmaVersion: 2022 } },
+        { code: "class C { static {\nfoo;\n} }", options: ["never"], parserOptions: { ecmaVersion: 2022 } },
+        { code: "class C { static { \n foo; \n } }", options: ["never"], parserOptions: { ecmaVersion: 2022 } }
     ],
 
     invalid: [
@@ -292,6 +301,170 @@ ruleTester.run("block-spacing", rule, {
             ]
         },
 
+        // class static blocks
+        {
+            code: "class C { static {foo; } }",
+            output: "class C { static { foo; } }",
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [
+                {
+                    type: "StaticBlock",
+                    messageId: "missing",
+                    data: {
+                        location: "after",
+                        token: "{"
+                    },
+                    line: 1,
+                    column: 18,
+                    endLine: 1,
+                    endColumn: 19
+                }
+            ]
+        },
+        {
+            code: "class C { static { foo;} }",
+            output: "class C { static { foo; } }",
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [
+                {
+                    type: "StaticBlock",
+                    messageId: "missing",
+                    data: {
+                        location: "before",
+                        token: "}"
+                    },
+                    line: 1,
+                    column: 24,
+                    endLine: 1,
+                    endColumn: 25
+                }
+            ]
+        },
+        {
+            code: "class C { static {foo;} }",
+            output: "class C { static { foo; } }",
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [
+                {
+                    type: "StaticBlock",
+                    messageId: "missing",
+                    data: {
+                        location: "after",
+                        token: "{"
+                    },
+                    line: 1,
+                    column: 18,
+                    endLine: 1,
+                    endColumn: 19
+                },
+                {
+                    type: "StaticBlock",
+                    messageId: "missing",
+                    data: {
+                        location: "before",
+                        token: "}"
+                    },
+                    line: 1,
+                    column: 23,
+                    endLine: 1,
+                    endColumn: 24
+                }
+            ]
+        },
+        {
+            code: "class C { static {/* comment */} }",
+            output: "class C { static { /* comment */ } }",
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [
+                {
+                    type: "StaticBlock",
+                    messageId: "missing",
+                    data: {
+                        location: "after",
+                        token: "{"
+                    },
+                    line: 1,
+                    column: 18,
+                    endLine: 1,
+                    endColumn: 19
+                },
+                {
+                    type: "StaticBlock",
+                    messageId: "missing",
+                    data: {
+                        location: "before",
+                        token: "}"
+                    },
+                    line: 1,
+                    column: 32,
+                    endLine: 1,
+                    endColumn: 33
+                }
+            ]
+        },
+        {
+            code: "class C { static {/* comment 1 */ foo; /* comment 2 */} }",
+            output: "class C { static { /* comment 1 */ foo; /* comment 2 */ } }",
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [
+                {
+                    type: "StaticBlock",
+                    messageId: "missing",
+                    data: {
+                        location: "after",
+                        token: "{"
+                    },
+                    line: 1,
+                    column: 18,
+                    endLine: 1,
+                    endColumn: 19
+                },
+                {
+                    type: "StaticBlock",
+                    messageId: "missing",
+                    data: {
+                        location: "before",
+                        token: "}"
+                    },
+                    line: 1,
+                    column: 55,
+                    endLine: 1,
+                    endColumn: 56
+                }
+            ]
+        },
+        {
+            code: "class C {\n static {foo()\nbar()} }",
+            output: "class C {\n static { foo()\nbar() } }",
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [
+                {
+                    type: "StaticBlock",
+                    messageId: "missing",
+                    data: {
+                        location: "after",
+                        token: "{"
+                    },
+                    line: 2,
+                    column: 9,
+                    endLine: 2,
+                    endColumn: 10
+                },
+                {
+                    type: "StaticBlock",
+                    messageId: "missing",
+                    data: {
+                        location: "before",
+                        token: "}"
+                    },
+                    line: 3,
+                    column: 6,
+                    endLine: 3,
+                    endColumn: 7
+                }
+            ]
+        },
+
         //----------------------------------------------------------------------
         // never
         {
@@ -817,6 +990,176 @@ ruleTester.run("block-spacing", rule, {
                     endColumn: 21
                 }
             ]
+        },
+
+        // class static blocks
+        {
+            code: "class C { static { foo;} }",
+            output: "class C { static {foo;} }",
+            options: ["never"],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [
+                {
+                    type: "StaticBlock",
+                    messageId: "extra",
+                    data: {
+                        location: "after",
+                        token: "{"
+                    },
+                    line: 1,
+                    column: 19,
+                    endLine: 1,
+                    endColumn: 20
+                }
+            ]
+        },
+        {
+            code: "class C { static {foo; } }",
+            output: "class C { static {foo;} }",
+            options: ["never"],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [
+                {
+                    type: "StaticBlock",
+                    messageId: "extra",
+                    data: {
+                        location: "before",
+                        token: "}"
+                    },
+                    line: 1,
+                    column: 23,
+                    endLine: 1,
+                    endColumn: 24
+                }
+            ]
+        },
+        {
+            code: "class C { static { foo; } }",
+            output: "class C { static {foo;} }",
+            options: ["never"],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [
+                {
+                    type: "StaticBlock",
+                    messageId: "extra",
+                    data: {
+                        location: "after",
+                        token: "{"
+                    },
+                    line: 1,
+                    column: 19,
+                    endLine: 1,
+                    endColumn: 20
+                },
+                {
+                    type: "StaticBlock",
+                    messageId: "extra",
+                    data: {
+                        location: "before",
+                        token: "}"
+                    },
+                    line: 1,
+                    column: 24,
+                    endLine: 1,
+                    endColumn: 25
+                }
+            ]
+        },
+        {
+            code: "class C { static { /* comment */ } }",
+            output: "class C { static {/* comment */} }",
+            options: ["never"],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [
+                {
+                    type: "StaticBlock",
+                    messageId: "extra",
+                    data: {
+                        location: "after",
+                        token: "{"
+                    },
+                    line: 1,
+                    column: 19,
+                    endLine: 1,
+                    endColumn: 20
+                },
+                {
+                    type: "StaticBlock",
+                    messageId: "extra",
+                    data: {
+                        location: "before",
+                        token: "}"
+                    },
+                    line: 1,
+                    column: 33,
+                    endLine: 1,
+                    endColumn: 34
+                }
+            ]
+        },
+        {
+            code: "class C { static { /* comment 1 */ foo; /* comment 2 */ } }",
+            output: "class C { static {/* comment 1 */ foo; /* comment 2 */} }",
+            options: ["never"],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [
+                {
+                    type: "StaticBlock",
+                    messageId: "extra",
+                    data: {
+                        location: "after",
+                        token: "{"
+                    },
+                    line: 1,
+                    column: 19,
+                    endLine: 1,
+                    endColumn: 20
+                },
+                {
+                    type: "StaticBlock",
+                    messageId: "extra",
+                    data: {
+                        location: "before",
+                        token: "}"
+                    },
+                    line: 1,
+                    column: 56,
+                    endLine: 1,
+                    endColumn: 57
+                }
+            ]
+        },
+        {
+            code: "class C { static\n{   foo()\nbar()  } }",
+            output: "class C { static\n{foo()\nbar()} }",
+            options: ["never"],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [
+                {
+                    type: "StaticBlock",
+                    messageId: "extra",
+                    data: {
+                        location: "after",
+                        token: "{"
+                    },
+                    line: 2,
+                    column: 2,
+                    endLine: 2,
+                    endColumn: 5
+                },
+                {
+                    type: "StaticBlock",
+                    messageId: "extra",
+                    data: {
+                        location: "before",
+                        token: "}"
+                    },
+                    line: 3,
+                    column: 6,
+                    endLine: 3,
+                    endColumn: 8
+                }
+            ]
         }
     ]
 });
diff --git a/tests/lib/rules/brace-style.js b/tests/lib/rules/brace-style.js
index 70211608b..9629f42fc 100644
--- a/tests/lib/rules/brace-style.js
+++ b/tests/lib/rules/brace-style.js
@@ -10,7 +10,8 @@
 //------------------------------------------------------------------------------
 
 const rule = require("../../../lib/rules/brace-style"),
-    { RuleTester } = require("../../../lib/rule-tester");
+    { RuleTester } = require("../../../lib/rule-tester"),
+    { unIndent } = require("../../_utils");
 
 //------------------------------------------------------------------------------
 // Tests
@@ -204,7 +205,125 @@ ruleTester.run("brace-style", rule, {
         `
           if (foo) bar = function() {}
           else baz()
-        `
+        `,
+
+        // class static blocks
+        {
+            code: unIndent`
+                class C {
+                    static {
+                        foo;
+                    }
+                }
+            `,
+            options: ["1tbs"],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: unIndent`
+                class C {
+                    static {}
+
+                    static {
+                    }
+                }
+            `,
+            options: ["1tbs"],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: unIndent`
+                class C {
+                    static { foo; }
+                }
+            `,
+            options: ["1tbs", { allowSingleLine: true }],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: unIndent`
+                class C {
+                    static {
+                        foo;
+                    }
+                }
+            `,
+            options: ["stroustrup"],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: unIndent`
+                class C {
+                    static {}
+
+                    static {
+                    }
+                }
+            `,
+            options: ["stroustrup"],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: unIndent`
+                class C {
+                    static { foo; }
+                }
+            `,
+            options: ["stroustrup", { allowSingleLine: true }],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: unIndent`
+                class C
+                {
+                    static
+                    {
+                        foo;
+                    }
+                }
+            `,
+            options: ["allman"],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: unIndent`
+                class C
+                {
+                    static
+                    {}
+                }
+            `,
+            options: ["allman"],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: unIndent`
+                class C
+                {
+                    static {}
+
+                    static { foo; }
+
+                    static
+                    { foo; }
+                }
+            `,
+            options: ["allman", { allowSingleLine: true }],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: unIndent`
+                class C {
+                    static {
+                        {
+                            foo;
+                        }
+                    }
+                }
+            `,
+            options: ["1tbs"],
+            parserOptions: { ecmaVersion: 2022 }
+        }
     ],
 
     invalid: [
@@ -664,6 +783,334 @@ ruleTester.run("brace-style", rule, {
                 { messageId: "nextLineOpen", type: "Punctuator" },
                 { messageId: "nextLineClose", type: "Punctuator" }
             ]
+        },
+
+        /*
+         * class static blocks
+         *
+         * Note about the autofix: this rule only inserts linebreaks and removes linebreaks.
+         * It does not aim to produce code with a valid indentation. Indentation and other formatting issues
+         * are expected to be fixed by `indent` and other rules in subsequent iterations.
+         */
+        {
+            code: unIndent`
+                class C {
+                    static
+                    {
+                        foo;
+                    }
+                }
+            `,
+            output: unIndent`
+                class C {
+                    static {
+                        foo;
+                    }
+                }
+            `,
+            options: ["1tbs"],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [
+                { messageId: "nextLineOpen", type: "Punctuator" }
+            ]
+        },
+        {
+            code: unIndent`
+                class C {
+                    static {foo;
+                    }
+                }
+            `,
+            output: unIndent`
+                class C {
+                    static {
+                foo;
+                    }
+                }
+            `,
+            options: ["1tbs"],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [
+                { messageId: "blockSameLine", type: "Punctuator" }
+            ]
+        },
+        {
+            code: unIndent`
+                class C {
+                    static {
+                        foo;}
+                }
+            `,
+            output: unIndent`
+                class C {
+                    static {
+                        foo;
+                }
+                }
+            `,
+            options: ["1tbs"],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [
+                { messageId: "singleLineClose", type: "Punctuator" }
+            ]
+        },
+        {
+            code: unIndent`
+                class C {
+                    static
+                    {foo;}
+                }
+            `,
+            output: unIndent`
+                class C {
+                    static {
+                foo;
+                }
+                }
+            `,
+            options: ["1tbs"],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [
+                { messageId: "nextLineOpen", type: "Punctuator" },
+                { messageId: "blockSameLine", type: "Punctuator" },
+                { messageId: "singleLineClose", type: "Punctuator" }
+            ]
+        },
+        {
+            code: unIndent`
+                class C {
+                    static
+                    {}
+                }
+            `,
+            output: unIndent`
+                class C {
+                    static {}
+                }
+            `,
+            options: ["1tbs"],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [
+                { messageId: "nextLineOpen", type: "Punctuator" }
+            ]
+        },
+        {
+            code: unIndent`
+                class C {
+                    static
+                    {
+                        foo;
+                    }
+                }
+            `,
+            output: unIndent`
+                class C {
+                    static {
+                        foo;
+                    }
+                }
+            `,
+            options: ["stroustrup"],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [
+                { messageId: "nextLineOpen", type: "Punctuator" }
+            ]
+        },
+        {
+            code: unIndent`
+                class C {
+                    static {foo;
+                    }
+                }
+            `,
+            output: unIndent`
+                class C {
+                    static {
+                foo;
+                    }
+                }
+            `,
+            options: ["stroustrup"],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [
+                { messageId: "blockSameLine", type: "Punctuator" }
+            ]
+        },
+        {
+            code: unIndent`
+                class C {
+                    static {
+                        foo;}
+                }
+            `,
+            output: unIndent`
+                class C {
+                    static {
+                        foo;
+                }
+                }
+            `,
+            options: ["stroustrup"],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [
+                { messageId: "singleLineClose", type: "Punctuator" }
+            ]
+        },
+        {
+            code: unIndent`
+                class C {
+                    static
+                    {foo;}
+                }
+            `,
+            output: unIndent`
+                class C {
+                    static {
+                foo;
+                }
+                }
+            `,
+            options: ["stroustrup"],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [
+                { messageId: "nextLineOpen", type: "Punctuator" },
+                { messageId: "blockSameLine", type: "Punctuator" },
+                { messageId: "singleLineClose", type: "Punctuator" }
+            ]
+        },
+        {
+            code: unIndent`
+                class C {
+                    static
+                    {}
+                }
+            `,
+            output: unIndent`
+                class C {
+                    static {}
+                }
+            `,
+            options: ["stroustrup"],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [
+                { messageId: "nextLineOpen", type: "Punctuator" }
+            ]
+        },
+        {
+            code: unIndent`
+                class C
+                {
+                    static{
+                        foo;
+                    }
+                }
+            `,
+            output: unIndent`
+                class C
+                {
+                    static
+                {
+                        foo;
+                    }
+                }
+            `,
+            options: ["allman"],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [
+                { messageId: "sameLineOpen", type: "Punctuator" }
+            ]
+        },
+        {
+            code: unIndent`
+                class C
+                {
+                    static
+                    {foo;
+                    }
+                }
+            `,
+            output: unIndent`
+                class C
+                {
+                    static
+                    {
+                foo;
+                    }
+                }
+            `,
+            options: ["allman"],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [
+                { messageId: "blockSameLine", type: "Punctuator" }
+            ]
+        },
+        {
+            code: unIndent`
+                class C
+                {
+                    static
+                    {
+                        foo;}
+                }
+            `,
+            output: unIndent`
+                class C
+                {
+                    static
+                    {
+                        foo;
+                }
+                }
+            `,
+            options: ["allman"],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [
+                { messageId: "singleLineClose", type: "Punctuator" }
+            ]
+        },
+        {
+            code: unIndent`
+                class C
+                {
+                    static{foo;}
+                }
+            `,
+            output: unIndent`
+                class C
+                {
+                    static
+                {
+                foo;
+                }
+                }
+            `,
+            options: ["allman"],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [
+                { messageId: "sameLineOpen", type: "Punctuator" },
+                { messageId: "blockSameLine", type: "Punctuator" },
+                { messageId: "singleLineClose", type: "Punctuator" }
+            ]
+        },
+        {
+            code: unIndent`
+                class C
+                {
+                    static{}
+                }
+            `,
+            output: unIndent`
+                class C
+                {
+                    static
+                {}
+                }
+            `,
+            options: ["allman"],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [
+                { messageId: "sameLineOpen", type: "Punctuator" }
+            ]
         }
     ]
 });
diff --git a/tests/lib/rules/class-methods-use-this.js b/tests/lib/rules/class-methods-use-this.js
index 95c1a6f64..eeb122f75 100644
--- a/tests/lib/rules/class-methods-use-this.js
+++ b/tests/lib/rules/class-methods-use-this.js
@@ -41,7 +41,8 @@ ruleTester.run("class-methods-use-this", rule, {
         { code: "class A { #bar() {} }", options: [{ exceptMethods: ["#bar"] }], parserOptions: { ecmaVersion: 2022 } },
         { code: "class A { foo = function () {} }", options: [{ enforceForClassFields: false }], parserOptions: { ecmaVersion: 2022 } },
         { code: "class A { foo = () => {} }", options: [{ enforceForClassFields: false }], parserOptions: { ecmaVersion: 2022 } },
-        { code: "class A { foo() { return class { [this.foo] = 1 }; } }", parserOptions: { ecmaVersion: 2022 } }
+        { code: "class A { foo() { return class { [this.foo] = 1 }; } }", parserOptions: { ecmaVersion: 2022 } },
+        { code: "class A { static {} }", parserOptions: { ecmaVersion: 2022 } }
     ],
     invalid: [
         {
@@ -203,6 +204,13 @@ ruleTester.run("class-methods-use-this", rule, {
             errors: [
                 { messageId: "missingThis", data: { name: "method 'foo'" }, column: 11, endColumn: 15 }
             ]
+        },
+        {
+            code: "class A { foo () { return class { static { this; } } } }",
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [
+                { messageId: "missingThis", data: { name: "method 'foo'" }, column: 11, endColumn: 15 }
+            ]
         }
     ]
 });
diff --git a/tests/lib/rules/complexity.js b/tests/lib/rules/complexity.js
index badde8a71..d6feb8a2f 100644
--- a/tests/lib/rules/complexity.js
+++ b/tests/lib/rules/complexity.js
@@ -104,6 +104,25 @@ ruleTester.run("complexity", rule, {
         { code: "class C { x = a || class { y = b || c; z = d || e; }; }", options: [2], parserOptions: { ecmaVersion: 2022 } },
         { code: "class C { x; y = a; static z; static q = b; }", options: [1], parserOptions: { ecmaVersion: 2022 } },
 
+        // class static blocks
+        { code: "function foo() { class C { static { a || b; } static { c || d; } } }", options: [2], parserOptions: { ecmaVersion: 2022 } },
+        { code: "function foo() { a || b; class C { static { c || d; } } }", options: [2], parserOptions: { ecmaVersion: 2022 } },
+        { code: "function foo() { class C { static { a || b; } } c || d; }", options: [2], parserOptions: { ecmaVersion: 2022 } },
+        { code: "function foo() { class C { static { a || b; } } class D { static { c || d; } } }", options: [2], parserOptions: { ecmaVersion: 2022 } },
+        { code: "class C { static { a || b; } static { c || d; } }", options: [2], parserOptions: { ecmaVersion: 2022 } },
+        { code: "class C { static { a || b; } static { c || d; } static { e || f; } }", options: [2], parserOptions: { ecmaVersion: 2022 } },
+        { code: "class C { static { () => a || b; c || d; } }", options: [2], parserOptions: { ecmaVersion: 2022 } },
+        { code: "class C { static { a || b; () => c || d; } static { c || d; } }", options: [2], parserOptions: { ecmaVersion: 2022 } },
+        { code: "class C { static { a } }", options: [1], parserOptions: { ecmaVersion: 2022 } },
+        { code: "class C { static { a } static { b } }", options: [1], parserOptions: { ecmaVersion: 2022 } },
+        { code: "class C { static { a || b; } } class D { static { c || d; } }", options: [2], parserOptions: { ecmaVersion: 2022 } },
+        { code: "class C { static { a || b; } static c = d || e; }", options: [2], parserOptions: { ecmaVersion: 2022 } },
+        { code: "class C { static a = b || c; static { c || d; } }", options: [2], parserOptions: { ecmaVersion: 2022 } },
+        { code: "class C { static { a || b; } c = d || e; }", options: [2], parserOptions: { ecmaVersion: 2022 } },
+        { code: "class C { a = b || c; static { d || e; } }", options: [2], parserOptions: { ecmaVersion: 2022 } },
+        { code: "class C { static { a || b; c || d; } }", options: [3], parserOptions: { ecmaVersion: 2022 } },
+        { code: "class C { static { if (a || b) c = d || e; } }", options: [4], parserOptions: { ecmaVersion: 2022 } },
+
         // object property options
         { code: "function b(x) {}", options: [{ max: 1 }] }
     ],
@@ -369,6 +388,139 @@ ruleTester.run("complexity", rule, {
             ]
         },
 
+        // class static blocks
+        {
+            code: "function foo () { a || b; class C { static {} } c || d; }",
+            options: [2],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [makeError("Function 'foo'", 3, 2)]
+        },
+        {
+            code: "function foo () { a || b; class C { static { c || d; } } e || f; }",
+            options: [2],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [makeError("Function 'foo'", 3, 2)]
+        },
+        {
+            code: "class C { static { a || b; }  }",
+            options: [1],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [makeError("Class static block", 2, 1)]
+        },
+        {
+            code: "class C { static { a || b || c; }  }",
+            options: [2],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [makeError("Class static block", 3, 2)]
+        },
+        {
+            code: "class C { static { a || b; c || d; }  }",
+            options: [2],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [makeError("Class static block", 3, 2)]
+        },
+        {
+            code: "class C { static { a || b; c || d; e || f; }  }",
+            options: [3],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [makeError("Class static block", 4, 3)]
+        },
+        {
+            code: "class C { static { a || b; c || d; { e || f; } }  }",
+            options: [3],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [makeError("Class static block", 4, 3)]
+        },
+        {
+            code: "class C { static { if (a || b) c = d || e; } }",
+            options: [3],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [makeError("Class static block", 4, 3)]
+        },
+        {
+            code: "class C { static { if (a || b) c = (d => e || f)() || (g => h || i)(); } }",
+            options: [3],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [makeError("Class static block", 4, 3)]
+        },
+        {
+            code: "class C { x(){ a || b; } static { c || d || e; } z() { f || g; } }",
+            options: [2],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [makeError("Class static block", 3, 2)]
+        },
+        {
+            code: "class C { x = a || b; static { c || d || e; } y = f || g; }",
+            options: [2],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [makeError("Class static block", 3, 2)]
+        },
+        {
+            code: "class C { static x = a || b; static { c || d || e; } static y = f || g; }",
+            options: [2],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [makeError("Class static block", 3, 2)]
+        },
+        {
+            code: "class C { static { a || b; } static(){ c || d || e; } static { f || g; } }",
+            options: [2],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [makeError("Method 'static'", 3, 2)]
+        },
+        {
+            code: "class C { static { a || b; } static static(){ c || d || e; } static { f || g; } }",
+            options: [2],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [makeError("Static method 'static'", 3, 2)]
+        },
+        {
+            code: "class C { static { a || b; } static x = c || d || e; static { f || g; } }",
+            options: [2],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{
+                ...makeError("Class field initializer", 3, 2),
+                column: 41,
+                endColumn: 52
+            }]
+        },
+        {
+            code: "class C { static { a || b || c || d; } static { e || f || g; } }",
+            options: [3],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{
+                ...makeError("Class static block", 4, 3),
+                column: 11,
+                endColumn: 39
+            }]
+        },
+        {
+            code: "class C { static { a || b || c; } static { d || e || f || g; } }",
+            options: [3],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{
+                ...makeError("Class static block", 4, 3),
+                column: 35,
+                endColumn: 63
+            }]
+        },
+        {
+            code: "class C { static { a || b || c || d; } static { e || f || g || h; } }",
+            options: [3],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [
+                {
+                    ...makeError("Class static block", 4, 3),
+                    column: 11,
+                    endColumn: 39
+                },
+                {
+                    ...makeError("Class static block", 4, 3),
+                    column: 40,
+                    endColumn: 68
+                }
+            ]
+        },
+
         // object property options
         { code: "function a(x) {}", options: [{ max: 0 }], errors: [makeError("Function 'a'", 1, 0)] }
     ]
diff --git a/tests/lib/rules/indent.js b/tests/lib/rules/indent.js
index 03086ce13..394767914 100644
--- a/tests/lib/rules/indent.js
+++ b/tests/lib/rules/indent.js
@@ -5847,6 +5847,241 @@ ruleTester.run("indent", rule, {
                                                         ar2){}
             `,
             options: [2, { FunctionDeclaration: { parameters: "first" }, FunctionExpression: { parameters: "first" } }]
+        },
+        {
+            code: unIndent`
+                class C {
+                  static {
+                    foo();
+                    bar();
+                  }
+                }
+            `,
+            options: [2],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: unIndent`
+                class C {
+                    static {
+                        foo();
+                        bar();
+                    }
+                }
+            `,
+            options: [4],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: unIndent`
+                class C {
+                    static {
+                            foo();
+                            bar();
+                    }
+                }
+            `,
+            options: [4, { StaticBlock: { body: 2 } }],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: unIndent`
+                class C {
+                    static {
+                    foo();
+                    bar();
+                    }
+                }
+            `,
+            options: [4, { StaticBlock: { body: 0 } }],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: unIndent`
+                class C {
+                \tstatic {
+                \t\tfoo();
+                \t\tbar();
+                \t}
+                }
+            `,
+            options: ["tab"],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: unIndent`
+                class C {
+                \tstatic {
+                \t\t\tfoo();
+                \t\t\tbar();
+                \t}
+                }
+            `,
+            options: ["tab", { StaticBlock: { body: 2 } }],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: unIndent`
+                class C {
+                    static
+                    {
+                        foo();
+                        bar();
+                    }
+                }
+            `,
+            options: [4],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: unIndent`
+                class C {
+                    static {
+                        var x,
+                            y;
+                    }
+                }
+            `,
+            options: [4],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: unIndent`
+                class C {
+                    static
+                    {
+                        var x,
+                            y;
+                    }
+                }
+            `,
+            options: [4],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: unIndent`
+                class C {
+                    static {
+                        if (foo) {
+                            bar;
+                        }
+                    }
+                }
+            `,
+            options: [4],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: unIndent`
+                class C {
+                    static {
+                        {
+                            bar;
+                        }
+                    }
+                }
+            `,
+            options: [4],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: unIndent`
+                class C {
+                    static {}
+
+                    static {
+                    }
+
+                    static
+                    {
+                    }
+                }
+            `,
+            options: [4],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: unIndent`
+                class C {
+
+                    static {
+                        foo;
+                    }
+
+                    static {
+                        bar;
+                    }
+
+                }
+            `,
+            options: [4],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: unIndent`
+                class C {
+
+                    x = 1;
+
+                    static {
+                        foo;
+                    }
+
+                    y = 2;
+
+                }
+            `,
+            options: [4],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: unIndent`
+                class C {
+
+                    method1(param) {
+                        foo;
+                    }
+
+                    static {
+                        bar;
+                    }
+
+                    method2(param) {
+                        foo;
+                    }
+
+                }
+            `,
+            options: [4],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: unIndent`
+                function f() {
+                    class C {
+                        static {
+                            foo();
+                            bar();
+                        }
+                    }
+                }
+            `,
+            options: [4],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: unIndent`
+                class C {
+                    method() {
+                            foo;
+                    }
+                    static {
+                            bar;
+                    }
+                }
+            `,
+            options: [4, { FunctionExpression: { body: 2 }, StaticBlock: { body: 2 } }],
+            parserOptions: { ecmaVersion: 2022 }
         }
     ],
 
@@ -11814,6 +12049,580 @@ ruleTester.run("indent", rule, {
                 [4, 8, 0, "Keyword"],
                 [5, 4, 0, "Punctuator"]
             ])
+        },
+        {
+            code: unIndent`
+                class C {
+                static {
+                foo();
+                bar();
+                }
+                }
+            `,
+            output: unIndent`
+                class C {
+                  static {
+                    foo();
+                    bar();
+                  }
+                }
+            `,
+            options: [2],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: expectedErrors([
+                [2, 2, 0, "Keyword"],
+                [3, 4, 0, "Identifier"],
+                [4, 4, 0, "Identifier"],
+                [5, 2, 0, "Punctuator"]
+            ])
+        },
+        {
+            code: unIndent`
+                class C {
+                static {
+                foo();
+                bar();
+                }
+                }
+            `,
+            output: unIndent`
+                class C {
+                    static {
+                        foo();
+                        bar();
+                    }
+                }
+            `,
+            options: [4],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: expectedErrors([
+                [2, 4, 0, "Keyword"],
+                [3, 8, 0, "Identifier"],
+                [4, 8, 0, "Identifier"],
+                [5, 4, 0, "Punctuator"]
+            ])
+        },
+        {
+            code: unIndent`
+                class C {
+                        static {
+                    foo();
+                bar();
+                        }
+                }
+            `,
+            output: unIndent`
+                class C {
+                    static {
+                        foo();
+                        bar();
+                    }
+                }
+            `,
+            options: [4],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: expectedErrors([
+                [2, 4, 8, "Keyword"],
+                [3, 8, 4, "Identifier"],
+                [4, 8, 0, "Identifier"],
+                [5, 4, 8, "Punctuator"]
+            ])
+        },
+        {
+            code: unIndent`
+                class C {
+                static {
+                foo();
+                bar();
+                }
+                }
+            `,
+            output: unIndent`
+                class C {
+                    static {
+                            foo();
+                            bar();
+                    }
+                }
+            `,
+            options: [4, { StaticBlock: { body: 2 } }],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: expectedErrors([
+                [2, 4, 0, "Keyword"],
+                [3, 12, 0, "Identifier"],
+                [4, 12, 0, "Identifier"],
+                [5, 4, 0, "Punctuator"]
+            ])
+        },
+        {
+            code: unIndent`
+                class C {
+                static {
+                foo();
+                bar();
+                }
+                }
+            `,
+            output: unIndent`
+                class C {
+                    static {
+                    foo();
+                    bar();
+                    }
+                }
+            `,
+            options: [4, { StaticBlock: { body: 0 } }],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: expectedErrors([
+                [2, 4, 0, "Keyword"],
+                [3, 4, 0, "Identifier"],
+                [4, 4, 0, "Identifier"],
+                [5, 4, 0, "Punctuator"]
+            ])
+        },
+        {
+            code: unIndent`
+                class C {
+                static {
+                foo();
+                bar();
+                }
+                }
+            `,
+            output: unIndent`
+                class C {
+                \tstatic {
+                \t\tfoo();
+                \t\tbar();
+                \t}
+                }
+            `,
+            options: ["tab"],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: expectedErrors("tab", [
+                [2, 1, 0, "Keyword"],
+                [3, 2, 0, "Identifier"],
+                [4, 2, 0, "Identifier"],
+                [5, 1, 0, "Punctuator"]
+            ])
+        },
+        {
+            code: unIndent`
+                class C {
+                static {
+                foo();
+                bar();
+                }
+                }
+            `,
+            output: unIndent`
+                class C {
+                \tstatic {
+                \t\t\tfoo();
+                \t\t\tbar();
+                \t}
+                }
+            `,
+            options: ["tab", { StaticBlock: { body: 2 } }],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: expectedErrors("tab", [
+                [2, 1, 0, "Keyword"],
+                [3, 3, 0, "Identifier"],
+                [4, 3, 0, "Identifier"],
+                [5, 1, 0, "Punctuator"]
+            ])
+        },
+        {
+            code: unIndent`
+                class C {
+                static
+                {
+                foo();
+                bar();
+                }
+                }
+            `,
+            output: unIndent`
+                class C {
+                    static
+                    {
+                        foo();
+                        bar();
+                    }
+                }
+            `,
+            options: [4],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: expectedErrors([
+                [2, 4, 0, "Keyword"],
+                [3, 4, 0, "Punctuator"],
+                [4, 8, 0, "Identifier"],
+                [5, 8, 0, "Identifier"],
+                [6, 4, 0, "Punctuator"]
+            ])
+        },
+        {
+            code: unIndent`
+                class C {
+                    static
+                        {
+                        foo();
+                        bar();
+                        }
+                }
+            `,
+            output: unIndent`
+                class C {
+                    static
+                    {
+                        foo();
+                        bar();
+                    }
+                }
+            `,
+            options: [4],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: expectedErrors([
+                [3, 4, 8, "Punctuator"],
+                [6, 4, 8, "Punctuator"]
+            ])
+        },
+        {
+            code: unIndent`
+                class C {
+                static {
+                var x,
+                y;
+                }
+                }
+            `,
+            output: unIndent`
+                class C {
+                    static {
+                        var x,
+                            y;
+                    }
+                }
+            `,
+            options: [4],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: expectedErrors([
+                [2, 4, 0, "Keyword"],
+                [3, 8, 0, "Keyword"],
+                [4, 12, 0, "Identifier"],
+                [5, 4, 0, "Punctuator"]
+            ])
+        },
+        {
+            code: unIndent`
+                class C {
+                static
+                {
+                var x,
+                y;
+                }
+                }
+            `,
+            output: unIndent`
+                class C {
+                    static
+                    {
+                        var x,
+                            y;
+                    }
+                }
+            `,
+            options: [4],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: expectedErrors([
+                [2, 4, 0, "Keyword"],
+                [3, 4, 0, "Punctuator"],
+                [4, 8, 0, "Keyword"],
+                [5, 12, 0, "Identifier"],
+                [6, 4, 0, "Punctuator"]
+            ])
+        },
+        {
+            code: unIndent`
+                class C {
+                static {
+                if (foo) {
+                bar;
+                }
+                }
+                }
+            `,
+            output: unIndent`
+                class C {
+                    static {
+                        if (foo) {
+                            bar;
+                        }
+                    }
+                }
+            `,
+            options: [4],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: expectedErrors([
+                [2, 4, 0, "Keyword"],
+                [3, 8, 0, "Keyword"],
+                [4, 12, 0, "Identifier"],
+                [5, 8, 0, "Punctuator"],
+                [6, 4, 0, "Punctuator"]
+            ])
+        },
+        {
+            code: unIndent`
+                class C {
+                static {
+                {
+                bar;
+                }
+                }
+                }
+            `,
+            output: unIndent`
+                class C {
+                    static {
+                        {
+                            bar;
+                        }
+                    }
+                }
+            `,
+            options: [4],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: expectedErrors([
+                [2, 4, 0, "Keyword"],
+                [3, 8, 0, "Punctuator"],
+                [4, 12, 0, "Identifier"],
+                [5, 8, 0, "Punctuator"],
+                [6, 4, 0, "Punctuator"]
+            ])
+        },
+        {
+            code: unIndent`
+                class C {
+                static {}
+
+                static {
+                }
+
+                static
+                {
+                }
+                }
+            `,
+            output: unIndent`
+                class C {
+                    static {}
+
+                    static {
+                    }
+
+                    static
+                    {
+                    }
+                }
+            `,
+            options: [4],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: expectedErrors([
+                [2, 4, 0, "Keyword"],
+                [4, 4, 0, "Keyword"],
+                [5, 4, 0, "Punctuator"],
+                [7, 4, 0, "Keyword"],
+                [8, 4, 0, "Punctuator"],
+                [9, 4, 0, "Punctuator"]
+            ])
+        },
+        {
+            code: unIndent`
+                class C {
+
+                static {
+                    foo;
+                }
+
+                static {
+                    bar;
+                }
+
+                }
+            `,
+            output: unIndent`
+                class C {
+
+                    static {
+                        foo;
+                    }
+
+                    static {
+                        bar;
+                    }
+
+                }
+            `,
+            options: [4],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: expectedErrors([
+                [3, 4, 0, "Keyword"],
+                [4, 8, 4, "Identifier"],
+                [5, 4, 0, "Punctuator"],
+                [7, 4, 0, "Keyword"],
+                [8, 8, 4, "Identifier"],
+                [9, 4, 0, "Punctuator"]
+            ])
+        },
+        {
+            code: unIndent`
+                class C {
+
+                x = 1;
+
+                static {
+                    foo;
+                }
+
+                y = 2;
+
+                }
+            `,
+            output: unIndent`
+                class C {
+
+                    x = 1;
+
+                    static {
+                        foo;
+                    }
+
+                    y = 2;
+
+                }
+            `,
+            options: [4],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: expectedErrors([
+                [3, 4, 0, "Identifier"],
+                [5, 4, 0, "Keyword"],
+                [6, 8, 4, "Identifier"],
+                [7, 4, 0, "Punctuator"],
+                [9, 4, 0, "Identifier"]
+            ])
+        },
+        {
+            code: unIndent`
+                class C {
+
+                method1(param) {
+                    foo;
+                }
+
+                static {
+                    bar;
+                }
+
+                method2(param) {
+                    foo;
+                }
+
+                }
+            `,
+            output: unIndent`
+                class C {
+
+                    method1(param) {
+                        foo;
+                    }
+
+                    static {
+                        bar;
+                    }
+
+                    method2(param) {
+                        foo;
+                    }
+
+                }
+            `,
+            options: [4],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: expectedErrors([
+                [3, 4, 0, "Identifier"],
+                [4, 8, 4, "Identifier"],
+                [5, 4, 0, "Punctuator"],
+                [7, 4, 0, "Keyword"],
+                [8, 8, 4, "Identifier"],
+                [9, 4, 0, "Punctuator"],
+                [11, 4, 0, "Identifier"],
+                [12, 8, 4, "Identifier"],
+                [13, 4, 0, "Punctuator"]
+            ])
+        },
+        {
+            code: unIndent`
+                function f() {
+                class C {
+                static {
+                foo();
+                bar();
+                }
+                }
+                }
+            `,
+            output: unIndent`
+                function f() {
+                    class C {
+                        static {
+                            foo();
+                            bar();
+                        }
+                    }
+                }
+            `,
+            options: [4],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: expectedErrors([
+                [2, 4, 0, "Keyword"],
+                [3, 8, 0, "Keyword"],
+                [4, 12, 0, "Identifier"],
+                [5, 12, 0, "Identifier"],
+                [6, 8, 0, "Punctuator"],
+                [7, 4, 0, "Punctuator"]
+            ])
+        },
+        {
+            code: unIndent`
+                class C {
+                method() {
+                foo;
+                }
+                static {
+                bar;
+                }
+                }
+            `,
+            output: unIndent`
+                class C {
+                    method() {
+                            foo;
+                    }
+                    static {
+                            bar;
+                    }
+                }
+            `,
+            options: [4, { FunctionExpression: { body: 2 }, StaticBlock: { body: 2 } }],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: expectedErrors([
+                [2, 4, 0, "Identifier"],
+                [3, 12, 0, "Identifier"],
+                [4, 4, 0, "Punctuator"],
+                [5, 4, 0, "Keyword"],
+                [6, 12, 0, "Identifier"],
+                [7, 4, 0, "Punctuator"]
+            ])
         }
     ]
 });
diff --git a/tests/lib/rules/keyword-spacing.js b/tests/lib/rules/keyword-spacing.js
index 05e58d7e1..35c8a06e4 100644
--- a/tests/lib/rules/keyword-spacing.js
+++ b/tests/lib/rules/keyword-spacing.js
@@ -978,6 +978,11 @@ ruleTester.run("keyword-spacing", rule, {
         { code: "class A { a;static[b]; }", options: [NEITHER], parserOptions: { ecmaVersion: 2022 } },
         { code: "class A { a; static #b; }", parserOptions: { ecmaVersion: 2022 } },
         { code: "class A { a;static#b; }", options: [NEITHER], parserOptions: { ecmaVersion: 2022 } },
+        { code: "class A { a() {} static {} }", parserOptions: { ecmaVersion: 2022 } },
+        { code: "class A { a() {}static{} }", options: [NEITHER], parserOptions: { ecmaVersion: 2022 } },
+        { code: "class A { a() {} static {} }", options: [override("static", BOTH)], parserOptions: { ecmaVersion: 2022 } },
+        { code: "class A { a() {}static{} }", options: [override("static", NEITHER)], parserOptions: { ecmaVersion: 2022 } },
+        { code: "class A { a() {}\nstatic\n{} }", options: [NEITHER], parserOptions: { ecmaVersion: 2022 } },
 
         // not conflict with `generator-star-spacing`
         { code: "class A { static* [a]() {} }", parserOptions: { ecmaVersion: 6 } },
@@ -986,6 +991,10 @@ ruleTester.run("keyword-spacing", rule, {
         // not conflict with `semi-spacing`
         { code: "class A { ;static a() {} }", parserOptions: { ecmaVersion: 6 } },
         { code: "class A { ; static a() {} }", options: [NEITHER], parserOptions: { ecmaVersion: 6 } },
+        { code: "class A { ;static a; }", parserOptions: { ecmaVersion: 2022 } },
+        { code: "class A { ; static a ; }", options: [NEITHER], parserOptions: { ecmaVersion: 2022 } },
+        { code: "class A { ;static {} }", parserOptions: { ecmaVersion: 2022 } },
+        { code: "class A { ; static{} }", options: [NEITHER], parserOptions: { ecmaVersion: 2022 } },
 
         //----------------------------------------------------------------------
         // super
@@ -3043,6 +3052,59 @@ ruleTester.run("keyword-spacing", rule, {
             parserOptions: { ecmaVersion: 2022 },
             errors: unexpectedAfter("static")
         },
+        {
+            code: "class A { a() {}static{} }",
+            output: "class A { a() {} static {} }",
+            parserOptions: { ecmaVersion: 2022 },
+            errors: expectedBeforeAndAfter("static")
+        },
+        {
+            code: "class A { a() {}static{} }",
+            output: "class A { a() {} static {} }",
+            options: [override("static", BOTH)],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: expectedBeforeAndAfter("static")
+        },
+        {
+            code: "class A {  a() {}static {} }",
+            output: "class A {  a() {} static {} }",
+            parserOptions: { ecmaVersion: 2022 },
+            errors: expectedBefore("static")
+        },
+        {
+            code: "class A {  a() {} static{} }",
+            output: "class A {  a() {} static {} }",
+            parserOptions: { ecmaVersion: 2022 },
+            errors: expectedAfter("static")
+        },
+        {
+            code: "class A { a() {} static {} }",
+            output: "class A { a() {}static{} }",
+            options: [NEITHER],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: unexpectedBeforeAndAfter("static")
+        },
+        {
+            code: "class A { a() {} static {} }",
+            output: "class A { a() {}static{} }",
+            options: [override("static", NEITHER)],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: unexpectedBeforeAndAfter("static")
+        },
+        {
+            code: "class A { a() {} static{} }",
+            output: "class A { a() {}static{} }",
+            options: [NEITHER],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: unexpectedBefore("static")
+        },
+        {
+            code: "class A { a() {}static {} }",
+            output: "class A { a() {}static{} }",
+            options: [NEITHER],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: unexpectedAfter("static")
+        },
 
         //----------------------------------------------------------------------
         // super
diff --git a/tests/lib/rules/lines-around-comment.js b/tests/lib/rules/lines-around-comment.js
index a4fd3dd70..2687f1458 100644
--- a/tests/lib/rules/lines-around-comment.js
+++ b/tests/lib/rules/lines-around-comment.js
@@ -9,7 +9,8 @@
 //------------------------------------------------------------------------------
 
 const rule = require("../../../lib/rules/lines-around-comment"),
-    { RuleTester } = require("../../../lib/rule-tester");
+    { RuleTester } = require("../../../lib/rule-tester"),
+    { unIndent } = require("../../_utils");
 
 //------------------------------------------------------------------------------
 // Tests
@@ -262,6 +263,106 @@ ruleTester.run("lines-around-comment", rule, {
                 allowBlockStart: true
             }]
         },
+        {
+            code: unIndent`
+                class C {
+                    static {
+                        // line comment
+                    }
+
+                    static {
+                        // line comment
+                        foo();
+                    }
+                }`,
+            options: [{
+                beforeLineComment: true,
+                allowBlockStart: true
+            }],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: unIndent`
+                class C {
+                    static
+                    {
+                        // line comment
+                    }
+
+                    static
+                    {
+                        // line comment
+                        foo();
+                    }
+                }`,
+            options: [{
+                beforeLineComment: true,
+                allowBlockStart: true
+            }],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: unIndent`
+                class C {
+                    static {
+                        /* block comment */
+                    }
+
+                    static {
+                        /* block
+                           comment */
+                    }
+
+                    static {
+                        /* block comment */
+                        foo();
+                    }
+
+                    static {
+                        /* block
+                           comment */
+                        foo();
+                    }
+                }`,
+            options: [{
+                beforeBlockComment: true,
+                allowBlockStart: true
+            }],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: unIndent`
+                class C {
+                    static
+                    {
+                        /* block comment */
+                    }
+
+                    static
+                    {
+                        /* block
+                        comment */
+                    }
+
+                    static
+                    {
+                        /* block comment */
+                        foo();
+                    }
+
+                    static
+                    {
+                        /* block
+                        comment */
+                        foo();
+                    }
+                }`,
+            options: [{
+                beforeBlockComment: true,
+                allowBlockStart: true
+            }],
+            parserOptions: { ecmaVersion: 2022 }
+        },
 
         // check for block end comments
         {
@@ -472,6 +573,54 @@ ruleTester.run("lines-around-comment", rule, {
                 allowBlockEnd: true
             }]
         },
+        {
+            code: unIndent`
+                class C {
+                    static {
+                        // line comment
+                    }
+
+                    static {
+                        foo();
+                        // line comment
+                    }
+                }`,
+            options: [{
+                afterLineComment: true,
+                allowBlockEnd: true
+            }],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: unIndent`
+                class C {
+                    static {
+                        /* block comment */
+                    }
+
+                    static {
+                        /* block
+                           comment */
+                    }
+
+                    static {
+                        foo();
+                        /* block comment */
+                    }
+
+                    static {
+                        foo();
+                        /* block
+                           comment */
+                    }
+                }`,
+            options: [{
+                beforeBlockComment: false, // default is `true`
+                afterBlockComment: true,
+                allowBlockEnd: true
+            }],
+            parserOptions: { ecmaVersion: 2022 }
+        },
 
         // check for object start comments
         {
@@ -1049,6 +1198,346 @@ ruleTester.run("lines-around-comment", rule, {
             }],
             errors: [{ messageId: "after", type: "Line", line: 8 }]
         },
+        {
+            code: unIndent`
+                class C {
+                    // line comment
+                    static{}
+                }`,
+            output: unIndent`
+                class C {
+                    // line comment
+
+                    static{}
+                }`,
+            options: [{
+                beforeLineComment: true,
+                afterLineComment: true,
+                allowBlockStart: true,
+                allowBlockEnd: true,
+                allowClassStart: true,
+                allowClassEnd: true
+            }],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [
+                { messageId: "after", type: "Line", line: 2 }
+            ]
+        },
+        {
+            code: unIndent`
+                class C {
+                    /* block
+                       comment */
+                    static{}
+                }`,
+            output: unIndent`
+                class C {
+                    /* block
+                       comment */
+
+                    static{}
+                }`,
+            options: [{
+                beforeBlockComment: true,
+                afterBlockComment: true,
+                allowBlockStart: true,
+                allowBlockEnd: true,
+                allowClassStart: true,
+                allowClassEnd: true
+            }],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [
+                { messageId: "after", type: "Block", line: 2 }
+            ]
+        },
+        {
+            code: unIndent`
+                class C {
+                    static
+                    // line comment
+                    {}
+                }`,
+            output: unIndent`
+            class C {
+                static
+
+                // line comment
+
+                {}
+            }`,
+            options: [{
+                beforeLineComment: true,
+                afterLineComment: true,
+                allowBlockStart: true,
+                allowBlockEnd: true,
+                allowClassStart: true,
+                allowClassEnd: true
+            }],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [
+                { messageId: "before", type: "Line", line: 3 },
+                { messageId: "after", type: "Line", line: 3 }
+            ]
+        },
+        {
+            code: unIndent`
+                class C {
+                    static
+                    /* block
+                       comment */
+                    {}
+                }`,
+            output: unIndent`
+            class C {
+                static
+
+                /* block
+                   comment */
+
+                {}
+            }`,
+            options: [{
+                beforeBlockComment: true,
+                afterBlockComment: true,
+                allowBlockStart: true,
+                allowBlockEnd: true,
+                allowClassStart: true,
+                allowClassEnd: true
+            }],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [
+                { messageId: "before", type: "Block", line: 3 },
+                { messageId: "after", type: "Block", line: 3 }
+            ]
+        },
+        {
+            code: unIndent`
+                class C {
+                    static {
+                        // line comment
+                        foo();
+                    }
+                }`,
+            output: unIndent`
+                class C {
+                    static {
+                        // line comment
+
+                        foo();
+                    }
+                }`,
+            options: [{
+                beforeLineComment: true,
+                afterLineComment: true,
+                allowBlockStart: true,
+                allowBlockEnd: true
+            }],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [
+                { messageId: "after", type: "Line", line: 3 }
+            ]
+        },
+        {
+            code: unIndent`
+                class C {
+                    static {
+                        /* block
+                           comment */
+                        foo();
+                    }
+                }`,
+            output: unIndent`
+                class C {
+                    static {
+                        /* block
+                           comment */
+
+                        foo();
+                    }
+                }`,
+            options: [{
+                beforeBlockComment: true,
+                afterBlockComment: true,
+                allowBlockStart: true,
+                allowBlockEnd: true
+            }],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [
+                { messageId: "after", type: "Block", line: 3 }
+            ]
+        },
+        {
+            code: unIndent`
+                class C {
+                    static {
+                        foo();
+                        // line comment
+                    }
+                }`,
+            output: unIndent`
+                class C {
+                    static {
+                        foo();
+
+                        // line comment
+                    }
+                }`,
+            options: [{
+                beforeLineComment: true,
+                afterLineComment: true,
+                allowBlockStart: true,
+                allowBlockEnd: true
+            }],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [
+                { messageId: "before", type: "Line", line: 4 }
+            ]
+        },
+        {
+            code: unIndent`
+                class C {
+                    static {
+                        foo();
+                        /* block
+                           comment */
+                    }
+                }`,
+            output: unIndent`
+                class C {
+                    static {
+                        foo();
+
+                        /* block
+                           comment */
+                    }
+                }`,
+            options: [{
+                beforeBlockComment: true,
+                afterBlockComment: true,
+                allowBlockStart: true,
+                allowBlockEnd: true
+            }],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [
+                { messageId: "before", type: "Block", line: 4 }
+            ]
+        },
+        {
+            code: unIndent`
+                class C {
+                    static {
+                        foo();
+                        // line comment
+                        bar();
+                    }
+                }`,
+            output: unIndent`
+                class C {
+                    static {
+                        foo();
+
+                        // line comment
+
+                        bar();
+                    }
+                }`,
+            options: [{
+                beforeLineComment: true,
+                afterLineComment: true,
+                allowBlockStart: true,
+                allowBlockEnd: true
+            }],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [
+                { messageId: "before", type: "Line", line: 4 },
+                { messageId: "after", type: "Line", line: 4 }
+            ]
+        },
+        {
+            code: unIndent`
+                class C {
+                    static {
+                        foo();
+                        /* block
+                           comment */
+                        bar();
+                    }
+                }`,
+            output: unIndent`
+                class C {
+                    static {
+                        foo();
+
+                        /* block
+                           comment */
+
+                        bar();
+                    }
+                }`,
+            options: [{
+                beforeBlockComment: true,
+                afterBlockComment: true,
+                allowBlockStart: true,
+                allowBlockEnd: true
+            }],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [
+                { messageId: "before", type: "Block", line: 4 },
+                { messageId: "after", type: "Block", line: 4 }
+            ]
+        },
+        {
+            code: unIndent`
+                class C {
+                    static{}
+                    // line comment
+                }`,
+            output: unIndent`
+                class C {
+                    static{}
+
+                    // line comment
+                }`,
+            options: [{
+                beforeLineComment: true,
+                afterLineComment: true,
+                allowBlockStart: true,
+                allowBlockEnd: true,
+                allowClassStart: true,
+                allowClassEnd: true
+            }],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [
+                { messageId: "before", type: "Line", line: 3 }
+            ]
+        },
+        {
+            code: unIndent`
+                class C {
+                    static{}
+                    /* block
+                       comment */
+                }`,
+            output: unIndent`
+                class C {
+                    static{}
+
+                    /* block
+                       comment */
+                }`,
+            options: [{
+                beforeBlockComment: true,
+                afterBlockComment: true,
+                allowBlockStart: true,
+                allowBlockEnd: true,
+                allowClassStart: true,
+                allowClassEnd: true
+            }],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [
+                { messageId: "before", type: "Block", line: 3 }
+            ]
+        },
 
         // object start comments
         {
diff --git a/tests/lib/rules/max-depth.js b/tests/lib/rules/max-depth.js
index 0b4f846dd..b35b60301 100644
--- a/tests/lib/rules/max-depth.js
+++ b/tests/lib/rules/max-depth.js
@@ -26,7 +26,18 @@ ruleTester.run("max-depth", rule, {
         "function foo() { if (true) { if (false) { if (true) { } } } }",
 
         // object property options
-        { code: "function foo() { if (true) { if (false) { if (true) { } } } }", options: [{ max: 3 }] }
+        { code: "function foo() { if (true) { if (false) { if (true) { } } } }", options: [{ max: 3 }] },
+
+        { code: "class C { static { if (1) { if (2) {} } } }", options: [2], parserOptions: { ecmaVersion: 2022 } },
+        { code: "class C { static { if (1) { if (2) {} } if (1) { if (2) {} } } }", options: [2], parserOptions: { ecmaVersion: 2022 } },
+        { code: "class C { static { if (1) { if (2) {} } } static { if (1) { if (2) {} } } }", options: [2], parserOptions: { ecmaVersion: 2022 } },
+        { code: "if (1) { class C { static { if (1) { if (2) {} } } } }", options: [2], parserOptions: { ecmaVersion: 2022 } },
+        { code: "function foo() { if (1) { class C { static { if (1) { if (2) {} } } } } }", options: [2], parserOptions: { ecmaVersion: 2022 } },
+        {
+            code: "function foo() { if (1) { if (2) { class C { static { if (1) { if (2) {} } if (1) { if (2) {} } } } } } if (1) { if (2) {} } }",
+            options: [2],
+            parserOptions: { ecmaVersion: 2022 }
+        }
     ],
     invalid: [
         { code: "function foo() { if (true) { if (false) { if (true) { } } } }", options: [2], errors: [{ messageId: "tooDeeply", data: { depth: 3, maxDepth: 2 }, type: "IfStatement" }] },
@@ -41,6 +52,51 @@ ruleTester.run("max-depth", rule, {
         { code: "function foo() { if (true) { if (false) { if (true) { } } } }", options: [{ max: 2 }], errors: [{ messageId: "tooDeeply", data: { depth: 3, maxDepth: 2 }, type: "IfStatement" }] },
 
         { code: "function foo() { if (a) { if (b) { if (c) { if (d) { if (e) {} } } } } }", options: [{}], errors: [{ messageId: "tooDeeply", data: { depth: 5, maxDepth: 4 } }] },
-        { code: "function foo() { if (true) {} }", options: [{ max: 0 }], errors: [{ messageId: "tooDeeply", data: { depth: 1, maxDepth: 0 } }] }
+        { code: "function foo() { if (true) {} }", options: [{ max: 0 }], errors: [{ messageId: "tooDeeply", data: { depth: 1, maxDepth: 0 } }] },
+
+        {
+            code: "class C { static { if (1) { if (2) { if (3) {} } } } }",
+            options: [2],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{
+                messageId: "tooDeeply",
+                data: { depth: 3, maxDepth: 2 },
+                line: 1,
+                column: 38
+            }]
+        },
+        {
+            code: "if (1) { class C { static { if (1) { if (2) { if (3) {} } } } } }",
+            options: [2],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{
+                messageId: "tooDeeply",
+                data: { depth: 3, maxDepth: 2 },
+                line: 1,
+                column: 47
+            }]
+        },
+        {
+            code: "function foo() { if (1) { class C { static { if (1) { if (2) { if (3) {} } } } } } }",
+            options: [2],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{
+                messageId: "tooDeeply",
+                data: { depth: 3, maxDepth: 2 },
+                line: 1,
+                column: 64
+            }]
+        },
+        {
+            code: "function foo() { if (1) { class C { static { if (1) { if (2) {} } } } if (2) { if (3) {} } } }",
+            options: [2],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{
+                messageId: "tooDeeply",
+                data: { depth: 3, maxDepth: 2 },
+                line: 1,
+                column: 80
+            }]
+        }
     ]
 });
diff --git a/tests/lib/rules/max-statements.js b/tests/lib/rules/max-statements.js
index fd939e592..decdd8a56 100644
--- a/tests/lib/rules/max-statements.js
+++ b/tests/lib/rules/max-statements.js
@@ -33,7 +33,33 @@ ruleTester.run("max-statements", rule, {
         { code: "var foo = { thing() { var bar = 1; var baz = 2; } }", options: [2], parserOptions: { ecmaVersion: 6 } },
         { code: "var foo = { ['thing']() { var bar = 1; var baz = 2; } }", options: [2], parserOptions: { ecmaVersion: 6 } },
         { code: "var foo = { thing: () => { var bar = 1; var baz = 2; } }", options: [2], parserOptions: { ecmaVersion: 6 } },
-        { code: "var foo = { thing: function() { var bar = 1; var baz = 2; } }", options: [{ max: 2 }] }
+        { code: "var foo = { thing: function() { var bar = 1; var baz = 2; } }", options: [{ max: 2 }] },
+
+        // this rule does not apply to class static blocks, and statements in them should not count as statements in the enclosing function
+        { code: "class C { static { one; two; three; { four; five; six; } } }", options: [2], parserOptions: { ecmaVersion: 2022 } },
+        { code: "function foo() { class C { static { one; two; three; { four; five; six; } } } }", options: [2], parserOptions: { ecmaVersion: 2022 } },
+        { code: "class C { static { one; two; three; function foo() { 1; 2; } four; five; six; } }", options: [2], parserOptions: { ecmaVersion: 2022 } },
+        { code: "class C { static { { one; two; three; function foo() { 1; 2; } four; five; six; } } }", options: [2], parserOptions: { ecmaVersion: 2022 } },
+        {
+            code: "function top_level() { 1; /* 2 */ class C { static { one; two; three; { four; five; six; } } } 3;}",
+            options: [2, { ignoreTopLevelFunctions: true }],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: "function top_level() { 1; 2; } class C { static { one; two; three; { four; five; six; } } }",
+            options: [1, { ignoreTopLevelFunctions: true }],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: "class C { static { one; two; three; { four; five; six; } } } function top_level() { 1; 2; } ",
+            options: [1, { ignoreTopLevelFunctions: true }],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: "function foo() { let one; let two = class { static { let three; let four; let five; if (six) { let seven; let eight; let nine; } } }; }",
+            options: [2],
+            parserOptions: { ecmaVersion: 2022 }
+        }
     ],
     invalid: [
         {
@@ -143,6 +169,30 @@ ruleTester.run("max-statements", rule, {
             code: "function foo() { 1; }",
             options: [{ max: 0 }],
             errors: [{ messageId: "exceed", data: { name: "Function 'foo'", count: 1, max: 0 } }]
+        },
+        {
+            code: "function foo() { foo_1; /* foo_ 2 */ class C { static { one; two; three; four; { five; six; seven; eight; } } } foo_3 }",
+            options: [2],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{ messageId: "exceed", data: { name: "Function 'foo'", count: 3, max: 2 } }]
+        },
+        {
+            code: "class C { static { one; two; three; four; function not_top_level() { 1; 2; 3; } five; six; seven; eight; } }",
+            options: [2, { ignoreTopLevelFunctions: true }],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{ messageId: "exceed", data: { name: "Function 'not_top_level'", count: 3, max: 2 } }]
+        },
+        {
+            code: "class C { static { { one; two; three; four; function not_top_level() { 1; 2; 3; } five; six; seven; eight; } } }",
+            options: [2, { ignoreTopLevelFunctions: true }],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{ messageId: "exceed", data: { name: "Function 'not_top_level'", count: 3, max: 2 } }]
+        },
+        {
+            code: "class C { static { { one; two; three; four; } function not_top_level() { 1; 2; 3; } { five; six; seven; eight; } } }",
+            options: [2, { ignoreTopLevelFunctions: true }],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{ messageId: "exceed", data: { name: "Function 'not_top_level'", count: 3, max: 2 } }]
         }
     ]
 });
diff --git a/tests/lib/rules/no-eval.js b/tests/lib/rules/no-eval.js
index 2f6f7f925..79ba4a1eb 100644
--- a/tests/lib/rules/no-eval.js
+++ b/tests/lib/rules/no-eval.js
@@ -50,6 +50,7 @@ ruleTester.run("no-eval", rule, {
         { code: "class A { static foo() { this.eval(); } }", parserOptions: { ecmaVersion: 6 } },
         { code: "class A { field = this.eval(); }", parserOptions: { ecmaVersion: 2022 } },
         { code: "class A { field = () => this.eval(); }", parserOptions: { ecmaVersion: 2022 } },
+        { code: "class A { static { this.eval(); } }", parserOptions: { ecmaVersion: 2022 } },
 
         // Allows indirect eval
         { code: "(0, eval)('foo')", options: [{ allowIndirect: true }] },
@@ -132,6 +133,12 @@ ruleTester.run("no-eval", rule, {
             code: "class C { [this.eval('foo')] }",
             parserOptions: { ecmaVersion: 2022 },
             errors: [{ messageId: "unexpected" }]
+        },
+
+        {
+            code: "class A { static {} [this.eval()]; }",
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{ messageId: "unexpected" }]
         }
     ]
 });
diff --git a/tests/lib/rules/no-extra-semi.js b/tests/lib/rules/no-extra-semi.js
index 838925e8c..4f19fb722 100644
--- a/tests/lib/rules/no-extra-semi.js
+++ b/tests/lib/rules/no-extra-semi.js
@@ -40,6 +40,7 @@ ruleTester.run("no-extra-semi", rule, {
         { code: "class A { } a;", parserOptions: { ecmaVersion: 6 } },
         { code: "class A { field; }", parserOptions: { ecmaVersion: 2022 } },
         { code: "class A { field = 0; }", parserOptions: { ecmaVersion: 2022 } },
+        { code: "class A { static { foo; } }", parserOptions: { ecmaVersion: 2022 } },
 
         // modules
         { code: "export const x = 42;", parserOptions: { ecmaVersion: 6, sourceType: "module" } },
@@ -112,6 +113,18 @@ ruleTester.run("no-extra-semi", rule, {
             output: "with(foo){}",
             errors: [{ messageId: "unexpected", type: "EmptyStatement" }]
         },
+        {
+            code: "class A { static { ; } }",
+            output: "class A { static {  } }",
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{ messageId: "unexpected", type: "EmptyStatement", column: 20 }]
+        },
+        {
+            code: "class A { static { a;; } }",
+            output: "class A { static { a; } }",
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{ messageId: "unexpected", type: "EmptyStatement", column: 22 }]
+        },
 
         // Class body.
         {
@@ -165,6 +178,18 @@ ruleTester.run("no-extra-semi", rule, {
             output: "class A { field; }",
             parserOptions: { ecmaVersion: 2022 },
             errors: [{ messageId: "unexpected", type: "Punctuator", column: 17 }]
+        },
+        {
+            code: "class A { static {}; }",
+            output: "class A { static {} }",
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{ messageId: "unexpected", type: "Punctuator", column: 20 }]
+        },
+        {
+            code: "class A { static { a; }; foo(){} }",
+            output: "class A { static { a; } foo(){} }",
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{ messageId: "unexpected", type: "Punctuator", column: 24 }]
         }
     ]
 });
diff --git a/tests/lib/rules/no-inner-declarations.js b/tests/lib/rules/no-inner-declarations.js
index a9f70fd3f..5fcb2f3c8 100644
--- a/tests/lib/rules/no-inner-declarations.js
+++ b/tests/lib/rules/no-inner-declarations.js
@@ -73,8 +73,27 @@ ruleTester.run("no-inner-declarations", rule, {
         {
             code: "module.exports = function foo(){}",
             options: ["both"]
+        },
+        {
+            code: "class C { method() { function foo() {} } }",
+            options: ["both"],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: "class C { method() { var x; } }",
+            options: ["both"],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: "class C { static { function foo() {} } }",
+            options: ["both"],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: "class C { static { var x; } }",
+            options: ["both"],
+            parserOptions: { ecmaVersion: 2022 }
         }
-
     ],
 
     // Examples of code that should trigger the rule
@@ -271,7 +290,54 @@ ruleTester.run("no-inner-declarations", rule, {
                 },
                 type: "VariableDeclaration"
             }]
+        }, {
+            code: "class C { method() { if(test) { var foo; } } }",
+            options: ["both"],
+            parserOptions: { ecmaVersion: 6 },
+            errors: [{
+                messageId: "moveDeclToRoot",
+                data: {
+                    type: "variable",
+                    body: "function body"
+                },
+                type: "VariableDeclaration"
+            }]
+        }, {
+            code: "class C { static { if (test) { function foo() {} } } }",
+            options: ["both"],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{
+                messageId: "moveDeclToRoot",
+                data: {
+                    type: "function",
+                    body: "class static block body"
+                },
+                type: "FunctionDeclaration"
+            }]
+        }, {
+            code: "class C { static { if (test) { var foo; } } }",
+            options: ["both"],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{
+                messageId: "moveDeclToRoot",
+                data: {
+                    type: "variable",
+                    body: "class static block body"
+                },
+                type: "VariableDeclaration"
+            }]
+        }, {
+            code: "class C { static { if (test) { if (anotherTest) { var foo; } } } }",
+            options: ["both"],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{
+                messageId: "moveDeclToRoot",
+                data: {
+                    type: "variable",
+                    body: "class static block body"
+                },
+                type: "VariableDeclaration"
+            }]
         }
-
     ]
 });
diff --git a/tests/lib/rules/no-invalid-this.js b/tests/lib/rules/no-invalid-this.js
index 80e4c9c3a..62033fd38 100644
--- a/tests/lib/rules/no-invalid-this.js
+++ b/tests/lib/rules/no-invalid-this.js
@@ -775,6 +775,54 @@ const patterns = [
         valid: [NORMAL], // the global this in non-strict mode is OK.
         invalid: [USE_STRICT, IMPLIED_STRICT, MODULES],
         errors: [{ messageId: "unexpectedThis", type: "ThisExpression" }]
+    },
+
+    // Class static blocks
+    {
+        code: "class C { static { this.x; } }",
+        parserOptions: { ecmaVersion: 2022 },
+        valid: [NORMAL, USE_STRICT, IMPLIED_STRICT, MODULES],
+        invalid: []
+    },
+    {
+        code: "class C { static { () => { this.x; } } }",
+        parserOptions: { ecmaVersion: 2022 },
+        valid: [NORMAL, USE_STRICT, IMPLIED_STRICT, MODULES],
+        invalid: []
+    },
+    {
+        code: "class C { static { class D { [this.x]; } } }",
+        parserOptions: { ecmaVersion: 2022 },
+        valid: [NORMAL, USE_STRICT, IMPLIED_STRICT, MODULES],
+        invalid: []
+    },
+    {
+        code: "class C { static { function foo() { this.x; } } }",
+        parserOptions: { ecmaVersion: 2022 },
+        valid: [],
+        invalid: [NORMAL, USE_STRICT, IMPLIED_STRICT, MODULES],
+        errors: [{ messageId: "unexpectedThis", type: "ThisExpression" }]
+    },
+    {
+        code: "class C { static { (function() { this.x; }); } }",
+        parserOptions: { ecmaVersion: 2022 },
+        valid: [],
+        invalid: [NORMAL, USE_STRICT, IMPLIED_STRICT, MODULES],
+        errors: [{ messageId: "unexpectedThis", type: "ThisExpression" }]
+    },
+    {
+        code: "class C { static { (function() { this.x; })(); } }",
+        parserOptions: { ecmaVersion: 2022 },
+        valid: [],
+        invalid: [NORMAL, USE_STRICT, IMPLIED_STRICT, MODULES],
+        errors: [{ messageId: "unexpectedThis", type: "ThisExpression" }]
+    },
+    {
+        code: "class C { static {} [this.x]; }",
+        parserOptions: { ecmaVersion: 2022 },
+        valid: [NORMAL],
+        invalid: [USE_STRICT, IMPLIED_STRICT, MODULES],
+        errors: [{ messageId: "unexpectedThis", type: "ThisExpression" }]
     }
 ];
 
diff --git a/tests/lib/rules/no-lone-blocks.js b/tests/lib/rules/no-lone-blocks.js
index d9ea851d4..ab81caf8e 100644
--- a/tests/lib/rules/no-lone-blocks.js
+++ b/tests/lib/rules/no-lone-blocks.js
@@ -57,7 +57,16 @@ ruleTester.run("no-lone-blocks", rule, {
             }
           }
         `,
-        { code: "function foo() { { const x = 4 } const x = 3 }", parserOptions: { ecmaVersion: 6 } }
+        { code: "function foo() { { const x = 4 } const x = 3 }", parserOptions: { ecmaVersion: 6 } },
+
+        { code: "class C { static {} }", parserOptions: { ecmaVersion: 2022 } },
+        { code: "class C { static { foo; } }", parserOptions: { ecmaVersion: 2022 } },
+        { code: "class C { static { if (foo) { block; } } }", parserOptions: { ecmaVersion: 2022 } },
+        { code: "class C { static { lbl: { block; } } }", parserOptions: { ecmaVersion: 2022 } },
+        { code: "class C { static { { let block; } something; } }", parserOptions: { ecmaVersion: 2022 } },
+        { code: "class C { static { something; { const block = 1; } } }", parserOptions: { ecmaVersion: 2022 } },
+        { code: "class C { static { { function block(){} } something; } }", parserOptions: { ecmaVersion: 2022 } },
+        { code: "class C { static { something; { class block {}  } } }", parserOptions: { ecmaVersion: 2022 } }
     ],
     invalid: [
         {
@@ -235,6 +244,202 @@ ruleTester.run("no-lone-blocks", rule, {
                 type: "BlockStatement",
                 line: 3
             }]
+        },
+        {
+            code: `
+              class C {
+                static {
+                  if (foo) {
+                    {
+                        let block;
+                    }
+                  }
+                }
+              }
+            `,
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{
+                messageId: "redundantNestedBlock",
+                type: "BlockStatement",
+                line: 5
+            }]
+        },
+        {
+            code: `
+              class C {
+                static {
+                  if (foo) {
+                    {
+                        block;
+                    }
+                    something;
+                  }
+                }
+              }
+            `,
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{
+                messageId: "redundantNestedBlock",
+                type: "BlockStatement",
+                line: 5
+            }]
+        },
+        {
+            code: `
+              class C {
+                static {
+                  {
+                    block;
+                  }
+                }
+              }
+            `,
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{
+                messageId: "redundantNestedBlock",
+                type: "BlockStatement",
+                line: 4
+            }]
+        },
+        {
+            code: `
+              class C {
+                static {
+                  {
+                    let block;
+                  }
+                }
+              }
+            `,
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{
+                messageId: "redundantNestedBlock",
+                type: "BlockStatement",
+                line: 4
+            }]
+        },
+        {
+            code: `
+              class C {
+                static {
+                  {
+                    const block = 1;
+                  }
+                }
+              }
+            `,
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{
+                messageId: "redundantNestedBlock",
+                type: "BlockStatement",
+                line: 4
+            }]
+        },
+        {
+            code: `
+              class C {
+                static {
+                  {
+                    function block() {}
+                  }
+                }
+              }
+            `,
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{
+                messageId: "redundantNestedBlock",
+                type: "BlockStatement",
+                line: 4
+            }]
+        },
+        {
+            code: `
+              class C {
+                static {
+                  {
+                    class block {}
+                  }
+                }
+              }
+            `,
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{
+                messageId: "redundantNestedBlock",
+                type: "BlockStatement",
+                line: 4
+            }]
+        },
+        {
+            code: `
+              class C {
+                static {
+                  {
+                    var block;
+                  }
+                  something;
+                }
+              }
+            `,
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{
+                messageId: "redundantNestedBlock",
+                type: "BlockStatement",
+                line: 4
+            }]
+        },
+        {
+            code: `
+              class C {
+                static {
+                  something;
+                  {
+                    var block;
+                  }
+                }
+              }
+            `,
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{
+                messageId: "redundantNestedBlock",
+                type: "BlockStatement",
+                line: 5
+            }]
+        },
+        {
+            code: `
+              class C {
+                static {
+                  {
+                    block;
+                  }
+                  something;
+                }
+              }
+            `,
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{
+                messageId: "redundantNestedBlock",
+                type: "BlockStatement",
+                line: 4
+            }]
+        },
+        {
+            code: `
+              class C {
+                static {
+                  something;
+                  {
+                    block;
+                  }
+                }
+              }
+            `,
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{
+                messageId: "redundantNestedBlock",
+                type: "BlockStatement",
+                line: 5
+            }]
         }
     ]
 });
diff --git a/tests/lib/rules/no-redeclare.js b/tests/lib/rules/no-redeclare.js
index f89d6853f..bbbe58081 100644
--- a/tests/lib/rules/no-redeclare.js
+++ b/tests/lib/rules/no-redeclare.js
@@ -28,6 +28,72 @@ ruleTester.run("no-redeclare", rule, {
                 ecmaVersion: 6
             }
         },
+        {
+            code: "var a; class C { static { var a; } }",
+            parserOptions: {
+                ecmaVersion: 2022
+            }
+        },
+        {
+            code: "class C { static { var a; } } var a; ",
+            parserOptions: {
+                ecmaVersion: 2022
+            }
+        },
+        {
+            code: "function a(){} class C { static { var a; } }",
+            parserOptions: {
+                ecmaVersion: 2022
+            }
+        },
+        {
+            code: "var a; class C { static { function a(){} } }",
+            parserOptions: {
+                ecmaVersion: 2022
+            }
+        },
+        {
+            code: "class C { static { var a; } static { var a; } }",
+            parserOptions: {
+                ecmaVersion: 2022
+            }
+        },
+        {
+            code: "class C { static { function a(){} } static { function a(){} } }",
+            parserOptions: {
+                ecmaVersion: 2022
+            }
+        },
+        {
+            code: "class C { static { var a; { function a(){} } } }",
+            parserOptions: {
+                ecmaVersion: 2022
+            }
+        },
+        {
+            code: "class C { static { function a(){}; { function a(){} } } }",
+            parserOptions: {
+                ecmaVersion: 2022
+            }
+        },
+        {
+            code: "class C { static { var a; { let a; } } }",
+            parserOptions: {
+                ecmaVersion: 2022
+            }
+        },
+        {
+            code: "class C { static { let a; { let a; } } }",
+            parserOptions: {
+                ecmaVersion: 2022
+            }
+        },
+        {
+            code: "class C { static { { let a; } { let a; } } }",
+            parserOptions: {
+                ecmaVersion: 2022
+            }
+        },
         { code: "var Object = 0;", options: [{ builtinGlobals: false }] },
         { code: "var Object = 0;", options: [{ builtinGlobals: true }], parserOptions: { ecmaVersion: 6, sourceType: "module" } },
         { code: "var Object = 0;", options: [{ builtinGlobals: true }], parserOptions: { ecmaFeatures: { globalReturn: true } } },
@@ -80,6 +146,37 @@ ruleTester.run("no-redeclare", rule, {
         { code: "var a = 3; var a = 10; var a = 15;", errors: [{ message: "'a' is already defined.", type: "Identifier" }, { message: "'a' is already defined.", type: "Identifier" }] },
         { code: "var a; var a;", parserOptions: { ecmaVersion: 6, sourceType: "module" }, errors: [{ message: "'a' is already defined.", type: "Identifier" }] },
         { code: "export var a; var a;", parserOptions: { ecmaVersion: 6, sourceType: "module" }, errors: [{ message: "'a' is already defined.", type: "Identifier" }] },
+
+        // `var` redeclaration in class static blocks. Redeclaration of functions is not allowed in class static blocks.
+        {
+            code: "class C { static { var a; var a; } }",
+            parserOptions: {
+                ecmaVersion: 2022
+            },
+            errors: [{ message: "'a' is already defined.", type: "Identifier" }]
+        },
+        {
+            code: "class C { static { var a; { var a; } } }",
+            parserOptions: {
+                ecmaVersion: 2022
+            },
+            errors: [{ message: "'a' is already defined.", type: "Identifier" }]
+        },
+        {
+            code: "class C { static { { var a; } var a; } }",
+            parserOptions: {
+                ecmaVersion: 2022
+            },
+            errors: [{ message: "'a' is already defined.", type: "Identifier" }]
+        },
+        {
+            code: "class C { static { { var a; } { var a; } } }",
+            parserOptions: {
+                ecmaVersion: 2022
+            },
+            errors: [{ message: "'a' is already defined.", type: "Identifier" }]
+        },
+
         {
             code: "var Object = 0;",
             options: [{ builtinGlobals: true }],
diff --git a/tests/lib/rules/no-shadow.js b/tests/lib/rules/no-shadow.js
index 036c65262..13c4c1100 100644
--- a/tests/lib/rules/no-shadow.js
+++ b/tests/lib/rules/no-shadow.js
@@ -58,7 +58,12 @@ ruleTester.run("no-shadow", rule, {
         { code: "var Object = 0;", options: [{ builtinGlobals: true }] },
         { code: "var top = 0;", options: [{ builtinGlobals: true }], env: { browser: true } },
         { code: "function foo(cb) { (function (cb) { cb(42); })(cb); }", options: [{ allow: ["cb"] }] },
-        { code: "class C { foo; foo() { let foo; } }", parserOptions: { ecmaVersion: 2022 } }
+        { code: "class C { foo; foo() { let foo; } }", parserOptions: { ecmaVersion: 2022 } },
+        { code: "class C { static { var x; } static { var x; } }", parserOptions: { ecmaVersion: 2022 } },
+        { code: "class C { static { let x; } static { let x; } }", parserOptions: { ecmaVersion: 2022 } },
+        { code: "class C { static { var x; { var x; /* redeclaration */ } } }", parserOptions: { ecmaVersion: 2022 } },
+        { code: "class C { static { { var x; } { var x; /* redeclaration */ } } }", parserOptions: { ecmaVersion: 2022 } },
+        { code: "class C { static { { let x; } { let x; } } }", parserOptions: { ecmaVersion: 2022 } }
     ],
     invalid: [
         {
@@ -716,6 +721,144 @@ ruleTester.run("no-shadow", rule, {
                 line: 1,
                 column: 31
             }]
+        },
+        {
+            code: "class C { static { let a; { let a; } } }",
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{
+                messageId: "noShadow",
+                data: {
+                    name: "a",
+                    shadowedLine: 1,
+                    shadowedColumn: 24
+                },
+                type: "Identifier",
+                line: 1,
+                column: 33
+            }]
+        },
+        {
+            code: "class C { static { var C; } }",
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{
+                messageId: "noShadow",
+                data: {
+                    name: "C",
+                    shadowedLine: 1,
+                    shadowedColumn: 7
+                },
+                type: "Identifier",
+                line: 1,
+                column: 24
+            }]
+        },
+        {
+            code: "class C { static { let C; } }",
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{
+                messageId: "noShadow",
+                data: {
+                    name: "C",
+                    shadowedLine: 1,
+                    shadowedColumn: 7
+                },
+                type: "Identifier",
+                line: 1,
+                column: 24
+            }]
+        },
+        {
+            code: "var a; class C { static { var a; } }",
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{
+                messageId: "noShadow",
+                data: {
+                    name: "a",
+                    shadowedLine: 1,
+                    shadowedColumn: 5
+                },
+                type: "Identifier",
+                line: 1,
+                column: 31
+            }]
+        },
+        {
+            code: "class C { static { var a; } } var a;",
+            options: [{ hoist: "all" }],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{
+                messageId: "noShadow",
+                data: {
+                    name: "a",
+                    shadowedLine: 1,
+                    shadowedColumn: 35
+                },
+                type: "Identifier",
+                line: 1,
+                column: 24
+            }]
+        },
+        {
+            code: "class C { static { let a; } } let a;",
+            options: [{ hoist: "all" }],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{
+                messageId: "noShadow",
+                data: {
+                    name: "a",
+                    shadowedLine: 1,
+                    shadowedColumn: 35
+                },
+                type: "Identifier",
+                line: 1,
+                column: 24
+            }]
+        },
+        {
+            code: "class C { static { var a; } } let a;",
+            options: [{ hoist: "all" }],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{
+                messageId: "noShadow",
+                data: {
+                    name: "a",
+                    shadowedLine: 1,
+                    shadowedColumn: 35
+                },
+                type: "Identifier",
+                line: 1,
+                column: 24
+            }]
+        },
+        {
+            code: "class C { static { var a; class D { static { var a; } } } }",
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{
+                messageId: "noShadow",
+                data: {
+                    name: "a",
+                    shadowedLine: 1,
+                    shadowedColumn: 24
+                },
+                type: "Identifier",
+                line: 1,
+                column: 50
+            }]
+        },
+        {
+            code: "class C { static { let a; class D { static { let a; } } } }",
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{
+                messageId: "noShadow",
+                data: {
+                    name: "a",
+                    shadowedLine: 1,
+                    shadowedColumn: 24
+                },
+                type: "Identifier",
+                line: 1,
+                column: 50
+            }]
         }
     ]
 });
diff --git a/tests/lib/rules/no-undef.js b/tests/lib/rules/no-undef.js
index 43697ec95..956bbc991 100644
--- a/tests/lib/rules/no-undef.js
+++ b/tests/lib/rules/no-undef.js
@@ -91,6 +91,67 @@ ruleTester.run("no-undef", rule, {
         {
             code: "import.meta",
             parserOptions: { ecmaVersion: 2020, sourceType: "module" }
+        },
+
+        // class static blocks
+        {
+            code: "let a; class C { static {} } a;",
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{ messageId: "undef", data: { name: "a" } }]
+        },
+        {
+            code: "var a; class C { static {} } a;",
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{ messageId: "undef", data: { name: "a" } }]
+        },
+        {
+            code: "a; class C { static {} } var a;",
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{ messageId: "undef", data: { name: "a" } }]
+        },
+        {
+            code: "class C { static { C; } }",
+            parserOptions: { ecmaVersion: 2022, sourceType: "module" }
+        },
+        {
+            code: "const C = class { static { C; } }",
+            parserOptions: { ecmaVersion: 2022, sourceType: "module" }
+        },
+        {
+            code: "class C { static { a; } } var a;",
+            parserOptions: { ecmaVersion: 2022, sourceType: "module" }
+        },
+        {
+            code: "class C { static { a; } } let a;",
+            parserOptions: { ecmaVersion: 2022, sourceType: "module" }
+        },
+        {
+            code: "class C { static { var a; a; } }",
+            parserOptions: { ecmaVersion: 2022, sourceType: "module" }
+        },
+        {
+            code: "class C { static { a; var a; } }",
+            parserOptions: { ecmaVersion: 2022, sourceType: "module" }
+        },
+        {
+            code: "class C { static { a; { var a; } } }",
+            parserOptions: { ecmaVersion: 2022, sourceType: "module" }
+        },
+        {
+            code: "class C { static { let a; a; } }",
+            parserOptions: { ecmaVersion: 2022, sourceType: "module" }
+        },
+        {
+            code: "class C { static { a; let a; } }",
+            parserOptions: { ecmaVersion: 2022, sourceType: "module" }
+        },
+        {
+            code: "class C { static { function a() {} a; } }",
+            parserOptions: { ecmaVersion: 2022, sourceType: "module" }
+        },
+        {
+            code: "class C { static { a; function a() {} } }",
+            parserOptions: { ecmaVersion: 2022, sourceType: "module" }
         }
     ],
     invalid: [
@@ -114,6 +175,99 @@ ruleTester.run("no-undef", rule, {
                 ecmaVersion: 2018
             },
             errors: [{ messageId: "undef", data: { name: "b" } }]
+        },
+
+        // class static blocks
+        {
+            code: "class C { static { a; } }",
+            parserOptions: {
+                ecmaVersion: 2022
+            },
+            errors: [{ messageId: "undef", data: { name: "a" } }]
+        },
+        {
+            code: "class C { static { { let a; } a; } }",
+            parserOptions: {
+                ecmaVersion: 2022
+            },
+            errors: [{ messageId: "undef", data: { name: "a" }, column: 31 }]
+        },
+        {
+            code: "class C { static { { function a() {} } a; } }",
+            parserOptions: {
+                ecmaVersion: 2022
+            },
+            errors: [{ messageId: "undef", data: { name: "a" }, column: 40 }]
+        },
+        {
+            code: "class C { static { function foo() { var a; }  a; } }",
+            parserOptions: {
+                ecmaVersion: 2022
+            },
+            errors: [{ messageId: "undef", data: { name: "a" }, column: 47 }]
+        },
+        {
+            code: "class C { static { var a; } static { a; } }",
+            parserOptions: {
+                ecmaVersion: 2022
+            },
+            errors: [{ messageId: "undef", data: { name: "a" }, column: 38 }]
+        },
+        {
+            code: "class C { static { let a; } static { a; } }",
+            parserOptions: {
+                ecmaVersion: 2022
+            },
+            errors: [{ messageId: "undef", data: { name: "a" }, column: 38 }]
+        },
+        {
+            code: "class C { static { function a(){} } static { a; } }",
+            parserOptions: {
+                ecmaVersion: 2022
+            },
+            errors: [{ messageId: "undef", data: { name: "a" }, column: 46 }]
+        },
+        {
+            code: "class C { static { var a; } foo() { a; } }",
+            parserOptions: {
+                ecmaVersion: 2022
+            },
+            errors: [{ messageId: "undef", data: { name: "a" }, column: 37 }]
+        },
+        {
+            code: "class C { static { let a; } foo() { a; } }",
+            parserOptions: {
+                ecmaVersion: 2022
+            },
+            errors: [{ messageId: "undef", data: { name: "a" }, column: 37 }]
+        },
+        {
+            code: "class C { static { var a; } [a]; }",
+            parserOptions: {
+                ecmaVersion: 2022
+            },
+            errors: [{ messageId: "undef", data: { name: "a" }, column: 30 }]
+        },
+        {
+            code: "class C { static { let a; } [a]; }",
+            parserOptions: {
+                ecmaVersion: 2022
+            },
+            errors: [{ messageId: "undef", data: { name: "a" }, column: 30 }]
+        },
+        {
+            code: "class C { static { function a() {} } [a]; }",
+            parserOptions: {
+                ecmaVersion: 2022
+            },
+            errors: [{ messageId: "undef", data: { name: "a" }, column: 39 }]
+        },
+        {
+            code: "class C { static { var a; } } a;",
+            parserOptions: {
+                ecmaVersion: 2022
+            },
+            errors: [{ messageId: "undef", data: { name: "a" }, column: 31 }]
         }
     ]
 });
diff --git a/tests/lib/rules/one-var.js b/tests/lib/rules/one-var.js
index b7ed53438..935c464b3 100644
--- a/tests/lib/rules/one-var.js
+++ b/tests/lib/rules/one-var.js
@@ -493,6 +493,143 @@ ruleTester.run("one-var", rule, {
         {
             code: "var foo = 1;\nlet bar = function() { var x; };\nvar baz = 2;",
             options: [{ var: "never" }]
+        },
+
+        // class static blocks
+        {
+            code: "class C { static { var a; let b; const c = 0; } }",
+            options: ["always"],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: "const a = 0; class C { static { const b = 0; } }",
+            options: ["always"],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: "class C { static { const b = 0; } } const a = 0; ",
+            options: ["always"],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: "let a; class C { static { let b; } }",
+            options: ["always"],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: "class C { static { let b; } } let a;",
+            options: ["always"],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: "var a; class C { static { var b; } }",
+            options: ["always"],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: "class C { static { var b; } } var a; ",
+            options: ["always"],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: "var a; class C { static { if (foo) { var b; } } }",
+            options: ["always"],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: "class C { static { if (foo) { var b; } } } var a; ",
+            options: ["always"],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: "class C { static { const a = 0; if (foo) { const b = 0; } } }",
+            options: ["always"],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: "class C { static { let a; if (foo) { let b; } } }",
+            options: ["always"],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: "class C { static { const a = 0; const b = 0; } }",
+            options: ["never"],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: "class C { static { let a; let b; } }",
+            options: ["never"],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: "class C { static { var a; var b; } }",
+            options: ["never"],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: "class C { static { let a; foo; let b; } }",
+            options: ["consecutive"],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: "class C { static { let a; const b = 0; let c; } }",
+            options: ["consecutive"],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: "class C { static { var a; foo; var b; } }",
+            options: ["consecutive"],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: "class C { static { var a; let b; var c; } }",
+            options: ["consecutive"],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: "class C { static { let a; if (foo) { let b; } } }",
+            options: ["consecutive"],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: "class C { static { if (foo) { let b; } let a;  } }",
+            options: ["consecutive"],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: "class C { static { const a = 0; if (foo) { const b = 0; } } }",
+            options: ["consecutive"],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: "class C { static { if (foo) { const b = 0; } const a = 0; } }",
+            options: ["consecutive"],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: "class C { static { var a; if (foo) var b; } }",
+            options: ["consecutive"],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: "class C { static { if (foo) var b; var a; } }",
+            options: ["consecutive"],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: "class C { static { if (foo) { var b; } var a; } }",
+            options: ["consecutive"],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: "class C { static { let a; let b = 0; } }",
+            options: [{ initialized: "consecutive" }],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: "class C { static { var a; var b = 0; } }",
+            options: [{ initialized: "consecutive" }],
+            parserOptions: { ecmaVersion: 2022 }
         }
     ],
     invalid: [
@@ -2118,6 +2255,129 @@ ruleTester.run("one-var", rule, {
                 data: { type: "var" },
                 type: "VariableDeclaration"
             }]
+        },
+
+        // class static blocks
+        {
+            code: "class C { static { let x, y; } }",
+            output: "class C { static { let x; let y; } }",
+            options: ["never"],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{
+                messageId: "split",
+                data: { type: "let" },
+                type: "VariableDeclaration"
+            }]
+        },
+        {
+            code: "class C { static { var x, y; } }",
+            output: "class C { static { var x; var y; } }",
+            options: ["never"],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{
+                messageId: "split",
+                data: { type: "var" },
+                type: "VariableDeclaration"
+            }]
+        },
+        {
+            code: "class C { static { let x; let y; } }",
+            output: "class C { static { let x,  y; } }",
+            options: ["always"],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{
+                messageId: "combine",
+                data: { type: "let" },
+                type: "VariableDeclaration"
+            }]
+        },
+        {
+            code: "class C { static { var x; var y; } }",
+            output: "class C { static { var x,  y; } }",
+            options: ["always"],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{
+                messageId: "combine",
+                data: { type: "var" },
+                type: "VariableDeclaration"
+            }]
+        },
+        {
+            code: "class C { static { let x; foo; let y; } }",
+            output: null,
+            options: ["always"],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{
+                messageId: "combine",
+                data: { type: "let" },
+                type: "VariableDeclaration"
+            }]
+        },
+        {
+            code: "class C { static { var x; foo; var y; } }",
+            output: null,
+            options: ["always"],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{
+                messageId: "combine",
+                data: { type: "var" },
+                type: "VariableDeclaration"
+            }]
+        },
+        {
+            code: "class C { static { var x; if (foo) { var y; } } }",
+            output: null,
+            options: ["always"],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{
+                messageId: "combine",
+                data: { type: "var" },
+                type: "VariableDeclaration"
+            }]
+        },
+        {
+            code: "class C { static { let x; let y; } }",
+            output: "class C { static { let x,  y; } }",
+            options: ["consecutive"],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{
+                messageId: "combine",
+                data: { type: "let" },
+                type: "VariableDeclaration"
+            }]
+        },
+        {
+            code: "class C { static { var x; var y; } }",
+            output: "class C { static { var x,  y; } }",
+            options: ["consecutive"],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{
+                messageId: "combine",
+                data: { type: "var" },
+                type: "VariableDeclaration"
+            }]
+        },
+        {
+            code: "class C { static { let a = 0; let b = 1; } }",
+            output: "class C { static { let a = 0,  b = 1; } }",
+            options: [{ initialized: "consecutive" }],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{
+                messageId: "combineInitialized",
+                data: { type: "let" },
+                type: "VariableDeclaration"
+            }]
+        },
+        {
+            code: "class C { static { var a = 0; var b = 1; } }",
+            output: "class C { static { var a = 0,  b = 1; } }",
+            options: [{ initialized: "consecutive" }],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{
+                messageId: "combineInitialized",
+                data: { type: "var" },
+                type: "VariableDeclaration"
+            }]
         }
     ]
 });
diff --git a/tests/lib/rules/padded-blocks.js b/tests/lib/rules/padded-blocks.js
index 76cfcda51..3dd0dc97e 100644
--- a/tests/lib/rules/padded-blocks.js
+++ b/tests/lib/rules/padded-blocks.js
@@ -88,7 +88,109 @@ ruleTester.run("padded-blocks", rule, {
 
         // Ignore class statements if not configured
         { code: "class A{\nfoo(){}\n}", options: [{ blocks: "always" }], parserOptions: { ecmaVersion: 6 } },
-        { code: "class A{\n\nfoo(){}\n\n}", options: [{ blocks: "never" }], parserOptions: { ecmaVersion: 6 } }
+        { code: "class A{\n\nfoo(){}\n\n}", options: [{ blocks: "never" }], parserOptions: { ecmaVersion: 6 } },
+
+        // class static blocks
+        {
+            code: "class C {\n\n static {\n\nfoo;\n\n} \n\n}",
+            options: ["always"],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: "class C {\n\n static {// comment\n\nfoo;\n\n/* comment */} \n\n}",
+            options: ["always"],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: "class C {\n\n static {\n\n// comment\nfoo;\n// comment\n\n} \n\n}",
+            options: ["always"],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: "class C {\n\n static {\n\n// comment\n\nfoo;\n\n// comment\n\n} \n\n}",
+            options: ["always"],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: "class C {\n\n static { foo; } \n\n}",
+            options: ["always", { allowSingleLineBlocks: true }],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: "class C {\n\n static\n { foo; } \n\n}",
+            options: ["always", { allowSingleLineBlocks: true }],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: "class C {\n\n static {} static {\n} static {\n\n} \n\n}", // empty blocks are ignored
+            options: ["always"],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: "class C {\n\n static\n\n { foo; } \n\n}",
+            options: ["always", { allowSingleLineBlocks: true }],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: "class C {\n static {\n\nfoo;\n\n} \n}",
+            options: [{ blocks: "always", classes: "never" }], // "blocks" applies to static blocks
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: "class C {\n static {\nfoo;\n} \n}",
+            options: ["never"],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: "class C {\n static {foo;} \n}",
+            options: ["never"],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: "class C {\n static\n {\nfoo;\n} \n}",
+            options: ["never"],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: "class C {\n static\n\n {\nfoo;\n} \n}",
+            options: ["never"],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: "class C {\n static\n\n {foo;} \n}",
+            options: ["never"],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: "class C {\n static {// comment\nfoo;\n/* comment */} \n}",
+            options: ["never"],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: "class C {\n static {\n// comment\nfoo;\n// comment\n} \n}",
+            options: ["never"],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: "class C {\n static {} static {\n} static {\n\n} \n}", // empty blocks are ignored
+            options: ["never"],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: "class C {\n\n static {\nfoo;\n} \n\n}",
+            options: [{ blocks: "never", classes: "always" }], // "blocks" applies to static blocks
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: "class C {\n\n static {\nfoo;\n} static {\n\nfoo;\n\n} \n\n}",
+            options: [{ classes: "always" }], // if there's no "blocks" in the object option, static blocks are ignored
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: "class C {\n static {\nfoo;\n} static {\n\nfoo;\n\n} \n}",
+            options: [{ classes: "never" }], // if there's no "blocks" in the object option, static blocks are ignored
+            parserOptions: { ecmaVersion: 2022 }
+        }
 
     ],
     invalid: [
@@ -764,6 +866,164 @@ ruleTester.run("padded-blocks", rule, {
             options: ["never"],
             parserOptions: { ecmaVersion: 2022 },
             errors: [{ messageId: "neverPadBlock" }, { messageId: "neverPadBlock" }]
+        },
+
+        // class static blocks
+        {
+            code: "class C {\n\n static {\nfoo;\n\n} \n\n}",
+            output: "class C {\n\n static {\n\nfoo;\n\n} \n\n}",
+            options: ["always"],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{ messageId: "alwaysPadBlock" }]
+        },
+        {
+            code: "class C {\n\n static\n {\nfoo;\n\n} \n\n}",
+            output: "class C {\n\n static\n {\n\nfoo;\n\n} \n\n}",
+            options: ["always"],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{ messageId: "alwaysPadBlock" }]
+        },
+        {
+            code: "class C {\n\n static\n\n {\nfoo;\n\n} \n\n}",
+            output: "class C {\n\n static\n\n {\n\nfoo;\n\n} \n\n}",
+            options: ["always"],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{ messageId: "alwaysPadBlock" }]
+        },
+        {
+            code: "class C {\n\n static {\n\nfoo;\n} \n\n}",
+            output: "class C {\n\n static {\n\nfoo;\n\n} \n\n}",
+            options: ["always"],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{ messageId: "alwaysPadBlock" }]
+        },
+        {
+            code: "class C {\n\n static {foo;} \n\n}",
+            output: "class C {\n\n static {\nfoo;\n} \n\n}", // this is still not padded, the subsequent fix below will add another pair of `\n`.
+            options: ["always"],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [
+                { messageId: "alwaysPadBlock" },
+                { messageId: "alwaysPadBlock" }
+            ]
+        },
+        {
+            code: "class C {\n\n static {\nfoo;\n} \n\n}",
+            output: "class C {\n\n static {\n\nfoo;\n\n} \n\n}",
+            options: ["always"],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [
+                { messageId: "alwaysPadBlock" },
+                { messageId: "alwaysPadBlock" }
+            ]
+        },
+        {
+            code: "class C {\n\n static {// comment\nfoo;\n/* comment */} \n\n}",
+            output: "class C {\n\n static {// comment\n\nfoo;\n\n/* comment */} \n\n}",
+            options: ["always"],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [
+                { messageId: "alwaysPadBlock" },
+                { messageId: "alwaysPadBlock" }
+            ]
+        },
+        {
+            code: "class C {\n\n static {\n// comment\nfoo;\n// comment\n} \n\n}",
+            output: "class C {\n\n static {\n\n// comment\nfoo;\n// comment\n\n} \n\n}",
+            options: ["always"],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [
+                { messageId: "alwaysPadBlock" },
+                { messageId: "alwaysPadBlock" }
+            ]
+        },
+        {
+            code: "class C {\n\n static {\n// comment\n\nfoo;\n\n// comment\n} \n\n}",
+            output: "class C {\n\n static {\n\n// comment\n\nfoo;\n\n// comment\n\n} \n\n}",
+            options: ["always"],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [
+                { messageId: "alwaysPadBlock" },
+                { messageId: "alwaysPadBlock" }
+            ]
+        },
+        {
+            code: "class C {\n static {\nfoo;\n} \n}",
+            output: "class C {\n static {\n\nfoo;\n\n} \n}",
+            options: [{ blocks: "always", classes: "never" }], // "blocks" applies to static blocks
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [
+                { messageId: "alwaysPadBlock" },
+                { messageId: "alwaysPadBlock" }
+            ]
+        },
+        {
+            code: "class C {\n static {\n\nfoo;\n} \n}",
+            output: "class C {\n static {\nfoo;\n} \n}",
+            options: ["never"],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{ messageId: "neverPadBlock" }]
+        },
+        {
+            code: "class C {\n static\n {\n\nfoo;\n} \n}",
+            output: "class C {\n static\n {\nfoo;\n} \n}",
+            options: ["never"],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{ messageId: "neverPadBlock" }]
+        },
+        {
+            code: "class C {\n static\n\n {\n\nfoo;\n} \n}",
+            output: "class C {\n static\n\n {\nfoo;\n} \n}",
+            options: ["never"],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{ messageId: "neverPadBlock" }]
+        },
+        {
+            code: "class C {\n static {\nfoo;\n\n} \n}",
+            output: "class C {\n static {\nfoo;\n} \n}",
+            options: ["never"],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{ messageId: "neverPadBlock" }]
+        },
+        {
+            code: "class C {\n static {\n\nfoo;\n\n} \n}",
+            output: "class C {\n static {\nfoo;\n} \n}",
+            options: ["never"],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [
+                { messageId: "neverPadBlock" },
+                { messageId: "neverPadBlock" }
+            ]
+        },
+        {
+            code: "class C {\n static {// comment\n\nfoo;\n\n/* comment */} \n}",
+            output: "class C {\n static {// comment\nfoo;\n/* comment */} \n}",
+            options: ["never"],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [
+                { messageId: "neverPadBlock" },
+                { messageId: "neverPadBlock" }
+            ]
+        },
+        {
+            code: "class C {\n static {\n\n// comment\nfoo;\n// comment\n\n} \n}",
+            output: "class C {\n static {\n// comment\nfoo;\n// comment\n} \n}",
+            options: ["never"],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [
+                { messageId: "neverPadBlock" },
+                { messageId: "neverPadBlock" }
+            ]
+        },
+        {
+            code: "class C {\n\n static {\n\nfoo;\n\n} \n\n}",
+            output: "class C {\n\n static {\nfoo;\n} \n\n}",
+            options: [{ blocks: "never", classes: "always" }], // "blocks" applies to static blocks
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [
+                { messageId: "neverPadBlock" },
+                { messageId: "neverPadBlock" }
+            ]
         }
     ]
 });
diff --git a/tests/lib/rules/padding-line-between-statements.js b/tests/lib/rules/padding-line-between-statements.js
index 931cdd24c..51ddf0eb3 100644
--- a/tests/lib/rules/padding-line-between-statements.js
+++ b/tests/lib/rules/padding-line-between-statements.js
@@ -2626,6 +2626,114 @@ ruleTester.run("padding-line-between-statements", rule, {
             options: [
                 { blankLine: "always", prev: "block-like", next: "block-like" }
             ]
+        },
+
+        // class static blocks
+        {
+            code: "class C {\n static {\n let x;\n\n foo();\n }\n }",
+            options: [
+                { blankLine: "always", prev: "let", next: "expression" }
+            ],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: "class C {\n static {\n let x;\n foo();\n }\n }",
+            options: [
+                { blankLine: "never", prev: "let", next: "expression" }
+            ],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: "class C {\n static {\n let x;\n foo();\n\n const y = 1;\n }\n }",
+            options: [
+                { blankLine: "always", prev: "expression", next: "const" }
+            ],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: "class C {\n static {\n let x;\n foo();\n const y = 1;\n }\n }",
+            options: [
+                { blankLine: "never", prev: "expression", next: "const" }
+            ],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: "class C {\n static {\n let x;\n foo();\n\n const y = 1;\n const z = 1;\n }\n }",
+            options: [
+                { blankLine: "always", prev: "expression", next: "const" }
+            ],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: "class C {\n static {\n let x;\n foo();\n const y = 1;\n const z = 1;\n }\n }",
+            options: [
+                { blankLine: "never", prev: "expression", next: "const" }
+            ],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: "class C {\n static {\n let a = 0;\n let b =0;\n\n bar();\n }\n }",
+            options: [
+                { blankLine: "always", prev: ["const", "let", "var"], next: "*" },
+                { blankLine: "any", prev: ["const", "let", "var"], next: ["const", "let", "var"] }
+            ],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: "class C { static { let x; { let y; } let z; } }",
+            options: [
+                { blankLine: "always", prev: "let", next: "let" }
+            ],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: "class C { method() { let x; } static { let y; } }",
+            options: [
+                { blankLine: "always", prev: "let", next: "let" }
+            ],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: "class C { static { let y; } method() { let x; } }",
+            options: [
+                { blankLine: "always", prev: "let", next: "let" }
+            ],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: "class C { static { let x; } static { let y; } }",
+            options: [
+                { blankLine: "always", prev: "let", next: "let" }
+            ],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: "let x; class C { static { let y; } }",
+            options: [
+                { blankLine: "always", prev: "let", next: "let" }
+            ],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: "class C { static { let x; } } let y;",
+            options: [
+                { blankLine: "always", prev: "let", next: "let" }
+            ],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: "class C { static { let x; } }",
+            options: [
+                { blankLine: "always", prev: "class", next: "let" }
+            ],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: "class C { static { 'use strict'; let x; } }", // 'use strict'; is "espression", because class static blocks don't have directives
+            options: [
+                { blankLine: "always", prev: "directive", next: "let" }
+            ],
+            parserOptions: { ecmaVersion: 2022 }
         }
     ],
     invalid: [
@@ -4976,6 +5084,117 @@ ruleTester.run("padding-line-between-statements", rule, {
                 { messageId: "expectedBlankLine" },
                 { messageId: "expectedBlankLine" }
             ]
+        },
+
+        // class static blocks
+        {
+            code: "class C {\n static {\n let x;\n foo();\n }\n }",
+            output: "class C {\n static {\n let x;\n\n foo();\n }\n }",
+            options: [
+                { blankLine: "always", prev: "let", next: "expression" }
+            ],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{ messageId: "expectedBlankLine" }]
+        },
+        {
+            code: "class C {\n static {\n let x;\n\n foo();\n }\n }",
+            output: "class C {\n static {\n let x;\n foo();\n }\n }",
+            options: [
+                { blankLine: "never", prev: "let", next: "expression" }
+            ],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{ messageId: "unexpectedBlankLine" }]
+        },
+        {
+            code: "class C {\n static {\n let x;\n foo();\n const y = 1;\n }\n }",
+            output: "class C {\n static {\n let x;\n foo();\n\n const y = 1;\n }\n }",
+            options: [
+                { blankLine: "always", prev: "expression", next: "const" }
+            ],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{ messageId: "expectedBlankLine" }]
+        },
+        {
+            code: "class C {\n static {\n let x;\n foo();\n\n const y = 1;\n }\n }",
+            output: "class C {\n static {\n let x;\n foo();\n const y = 1;\n }\n }",
+            options: [
+                { blankLine: "never", prev: "expression", next: "const" }
+            ],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{ messageId: "unexpectedBlankLine" }]
+        },
+        {
+            code: "class C {\n static {\n let x;\n foo();\n const y = 1;\n const z = 1;\n }\n }",
+            output: "class C {\n static {\n let x;\n foo();\n\n const y = 1;\n const z = 1;\n }\n }",
+            options: [
+                { blankLine: "always", prev: "expression", next: "const" }
+            ],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{ messageId: "expectedBlankLine" }]
+        },
+        {
+            code: "class C {\n static {\n let x;\n foo();\n\n const y = 1;\n const z = 1;\n }\n }",
+            output: "class C {\n static {\n let x;\n foo();\n const y = 1;\n const z = 1;\n }\n }",
+            options: [
+                { blankLine: "never", prev: "expression", next: "const" }
+            ],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{ messageId: "unexpectedBlankLine" }]
+        },
+        {
+            code: "class C {\n static {\n let a = 0;\n bar();\n }\n }",
+            output: "class C {\n static {\n let a = 0;\n\n bar();\n }\n }",
+            options: [
+                { blankLine: "always", prev: ["const", "let", "var"], next: "*" },
+                { blankLine: "any", prev: ["const", "let", "var"], next: ["const", "let", "var"] }
+            ],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{ messageId: "expectedBlankLine" }]
+        },
+        {
+            code: "class C { static { let x; { let y; let z; } let q; } }",
+            output: "class C { static { let x; { let y;\n\n let z; } let q; } }",
+            options: [
+                { blankLine: "always", prev: "let", next: "let" }
+            ],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{ messageId: "expectedBlankLine" }]
+        },
+        {
+            code: "class C { static { { let x; } let y; let z; } }",
+            output: "class C { static { { let x; } let y;\n\n let z; } }",
+            options: [
+                { blankLine: "always", prev: "let", next: "let" }
+            ],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{ messageId: "expectedBlankLine" }]
+        },
+        {
+            code: "class C { static { foo(); if (bar) {} } }",
+            output: "class C { static { foo();\n\n if (bar) {} } }",
+            options: [
+                { blankLine: "always", prev: "expression", next: "block-like" }
+            ],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{ messageId: "expectedBlankLine" }]
+        },
+        {
+            code: "class C { static { let x; } } let y;",
+            output: "class C { static { let x; } }\n\n let y;",
+            options: [
+                { blankLine: "always", prev: "class", next: "let" }
+            ],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{ messageId: "expectedBlankLine" }]
+        },
+        {
+            code: "class C { static { 'use strict'; let x; } }", // 'use strict'; is "espression", because class static blocks don't have directives
+            output: "class C { static { 'use strict';\n\n let x; } }",
+            options: [
+                { blankLine: "always", prev: "expression", next: "let" }
+            ],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{ messageId: "expectedBlankLine" }]
         }
     ]
 });
diff --git a/tests/lib/rules/prefer-const.js b/tests/lib/rules/prefer-const.js
index c591d2365..0a44b0bd0 100644
--- a/tests/lib/rules/prefer-const.js
+++ b/tests/lib/rules/prefer-const.js
@@ -173,7 +173,56 @@ ruleTester.run("prefer-const", rule, {
 
         // https://github.com/eslint/eslint/issues/10520
         "const x = [1,2]; let y; [,y] = x; y = 0;",
-        "const x = [1,2,3]; let y, z; [y,,z] = x; y = 0; z = 0;"
+        "const x = [1,2,3]; let y, z; [y,,z] = x; y = 0; z = 0;",
+
+        {
+            code: "class C { static { let a = 1; a = 2; } }",
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: "class C { static { let a; a = 1; a = 2; } }",
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: "let a; class C { static { a = 1; } }",
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: "class C { static { let a; if (foo) { a = 1; } } }",
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: "class C { static { let a; if (foo) a = 1; } }",
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: "class C { static { let a, b; if (foo) { ({ a, b } = foo); } } }",
+            output: null,
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [
+                { messageId: "useConst", data: { name: "a" }, type: "Identifier" },
+                { messageId: "useConst", data: { name: "b" }, type: "Identifier" }
+            ]
+        },
+        {
+            code: "class C { static { let a, b; if (foo) ({ a, b } = foo); } }",
+            output: null,
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [
+                { messageId: "useConst", data: { name: "a" }, type: "Identifier" },
+                { messageId: "useConst", data: { name: "b" }, type: "Identifier" }
+            ]
+        },
+        {
+            code: "class C { static { a; } } let a = 1; ",
+            options: [{ ignoreReadBeforeAssign: true }],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: "class C { static { () => a; let a = 1; } };",
+            options: [{ ignoreReadBeforeAssign: true }],
+            parserOptions: { ecmaVersion: 2022 }
+        }
     ],
     invalid: [
         {
@@ -555,6 +604,86 @@ ruleTester.run("prefer-const", rule, {
             code: "/*eslint no-undef-init:error*/ let foo = undefined;",
             output: "/*eslint no-undef-init:error*/ const foo = undefined;",
             errors: 2
+        },
+
+        {
+            code: "let a = 1; class C { static { a; } }",
+            output: "const a = 1; class C { static { a; } }",
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{ messageId: "useConst", data: { name: "a" }, type: "Identifier" }]
+        },
+        {
+
+            // this is a TDZ error with either `let` or `const`, but that isn't a concern of this rule
+            code: "class C { static { a; } } let a = 1;",
+            output: "class C { static { a; } } const a = 1;",
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{ messageId: "useConst", data: { name: "a" }, type: "Identifier" }]
+        },
+        {
+            code: "class C { static { let a = 1; } }",
+            output: "class C { static { const a = 1; } }",
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{ messageId: "useConst", data: { name: "a" }, type: "Identifier" }]
+        },
+        {
+            code: "class C { static { if (foo) { let a = 1; } } }",
+            output: "class C { static { if (foo) { const a = 1; } } }",
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{ messageId: "useConst", data: { name: "a" }, type: "Identifier" }]
+        },
+        {
+            code: "class C { static { let a = 1; if (foo) { a; } } }",
+            output: "class C { static { const a = 1; if (foo) { a; } } }",
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{ messageId: "useConst", data: { name: "a" }, type: "Identifier" }]
+        },
+        {
+            code: "class C { static { if (foo) { let a; a = 1; } } }",
+            output: null,
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{ messageId: "useConst", data: { name: "a" }, type: "Identifier" }]
+        },
+        {
+            code: "class C { static { let a; a = 1; } }",
+            output: null,
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{ messageId: "useConst", data: { name: "a" }, type: "Identifier", column: 27 }]
+        },
+        {
+            code: "class C { static { let { a, b } = foo; } }",
+            output: "class C { static { const { a, b } = foo; } }",
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [
+                { messageId: "useConst", data: { name: "a" }, type: "Identifier" },
+                { messageId: "useConst", data: { name: "b" }, type: "Identifier" }
+            ]
+        },
+        {
+            code: "class C { static { let a, b; ({ a, b } = foo); } }",
+            output: null,
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [
+                { messageId: "useConst", data: { name: "a" }, type: "Identifier" },
+                { messageId: "useConst", data: { name: "b" }, type: "Identifier" }
+            ]
+        },
+        {
+            code: "class C { static { let a; let b; ({ a, b } = foo); } }",
+            output: null,
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [
+                { messageId: "useConst", data: { name: "a" }, type: "Identifier" },
+                { messageId: "useConst", data: { name: "b" }, type: "Identifier" }
+            ]
+        },
+        {
+            code: "class C { static { let a; a = 0; console.log(a); } }",
+            output: null,
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [
+                { messageId: "useConst", data: { name: "a" }, type: "Identifier" }
+            ]
         }
     ]
 });
diff --git a/tests/lib/rules/semi-spacing.js b/tests/lib/rules/semi-spacing.js
index c9cccddd5..ffd67854a 100644
--- a/tests/lib/rules/semi-spacing.js
+++ b/tests/lib/rules/semi-spacing.js
@@ -483,6 +483,19 @@ ruleTester.run("semi-spacing", rule, {
                     endColumn: 16
                 }
             ]
+        },
+        {
+            code: "class C { foo;static {}}",
+            output: "class C { foo; static {}}",
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{
+                messageId: "missingWhitespaceAfter",
+                type: "PropertyDefinition",
+                line: 1,
+                column: 14,
+                endLine: 1,
+                endColumn: 15
+            }]
         }
     ]
 });
diff --git a/tests/lib/rules/semi-style.js b/tests/lib/rules/semi-style.js
index 82d9575de..7ab8f223f 100644
--- a/tests/lib/rules/semi-style.js
+++ b/tests/lib/rules/semi-style.js
@@ -127,6 +127,202 @@ ruleTester.run("semi-style", rule, {
                 while (a)
             `,
             options: ["last"]
+        },
+
+        // Class static blocks
+        {
+            code: `
+                class C {
+                    static {}
+                }
+            `,
+            options: ["last"],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: `
+                class C {
+                    static {
+                        foo
+                    }
+                }
+            `,
+            options: ["last"],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: `
+                class C {
+                    static {
+                        foo
+                        bar
+                    }
+                }
+            `,
+            options: ["last"],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: `
+                class C {
+                    static {
+                        ;
+                    }
+                }
+            `,
+            options: ["last"],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: `
+                class C {
+                    static {
+                        foo;
+                    }
+                }
+            `,
+            options: ["last"],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: `
+                class C {
+                    static {
+                        foo;
+                        bar;
+                    }
+                }
+            `,
+            options: ["last"],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: `
+                class C {
+                    static {
+                        foo;
+                        bar;
+                        baz;
+                    }
+                }
+            `,
+            options: ["last"],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: `
+                class C {
+                    static {}
+                }
+            `,
+            options: ["first"],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: `
+                class C {
+                    static {
+                        foo
+                    }
+                }
+            `,
+            options: ["first"],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: `
+                class C {
+                    static {
+                        foo
+                        bar
+                    }
+                }
+            `,
+            options: ["first"],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: `
+                class C {
+                    static {
+                        ;
+                    }
+                }
+            `,
+            options: ["first"],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: `
+                class C {
+                    static {
+                        ;foo
+                    }
+                }
+            `,
+            options: ["first"],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: `
+                class C {
+                    static {
+                        foo;
+                    }
+                }
+            `,
+            options: ["first"],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: `
+                class C {
+                    static {
+                        foo
+                        ;bar
+                    }
+                }
+            `,
+            options: ["first"],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: `
+                class C {
+                    static {
+                        foo
+                        ;bar;
+                    }
+                }
+            `,
+            options: ["first"],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: `
+                class C {
+                    static {
+                        foo
+                        ;bar
+                        ;baz
+                    }
+                }
+            `,
+            options: ["first"],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: `
+                class C {
+                    static {
+                        foo
+                        ;bar
+                        ;baz;
+                    }
+                }
+            `,
+            options: ["first"],
+            parserOptions: { ecmaVersion: 2022 }
         }
     ],
     invalid: [
@@ -414,6 +610,56 @@ ruleTester.run("semi-style", rule, {
                     pos: "the beginning of the next line"
                 }
             }]
+        },
+
+        // Class static blocks
+        {
+            code: "class C { static { foo\n; } }",
+            output: "class C { static { foo;\n} }",
+            options: ["last"],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{
+                messageId: "expectedSemiColon",
+                data: {
+                    pos: "the end of the previous line"
+                }
+            }]
+        },
+        {
+            code: "class C { static { foo\n ;bar } }",
+            output: "class C { static { foo;\nbar } }",
+            options: ["last"],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{
+                messageId: "expectedSemiColon",
+                data: {
+                    pos: "the end of the previous line"
+                }
+            }]
+        },
+        {
+            code: "class C { static { foo;\nbar\n ; } }",
+            output: "class C { static { foo;\nbar;\n} }",
+            options: ["last"],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{
+                messageId: "expectedSemiColon",
+                data: {
+                    pos: "the end of the previous line"
+                }
+            }]
+        },
+        {
+            code: "class C { static { foo;\nbar } }",
+            output: "class C { static { foo\n;bar } }",
+            options: ["first"],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{
+                messageId: "expectedSemiColon",
+                data: {
+                    pos: "the beginning of the next line"
+                }
+            }]
         }
     ]
 });
diff --git a/tests/lib/rules/semi.js b/tests/lib/rules/semi.js
index bc00079d8..d87382182 100644
--- a/tests/lib/rules/semi.js
+++ b/tests/lib/rules/semi.js
@@ -48,14 +48,73 @@ ruleTester.run("semi", rule, {
         { code: "for (let thing of {}) {\n  console.log(thing);\n}", parserOptions: { ecmaVersion: 6 } },
         { code: "do{}while(true)", options: ["never"] },
         { code: "do{}while(true);", options: ["always"] },
+        { code: "class C { static {} }", parserOptions: { ecmaVersion: 2022 } },
+        { code: "class C { static {} }", options: ["never"], parserOptions: { ecmaVersion: 2022 } },
+        { code: "class C { static { foo(); } }", parserOptions: { ecmaVersion: 2022 } },
+        { code: "class C { static { foo(); } }", options: ["always"], parserOptions: { ecmaVersion: 2022 } },
+        { code: "class C { static { foo(); bar(); } }", parserOptions: { ecmaVersion: 2022 } },
+        { code: "class C { static { foo(); bar(); baz();} }", parserOptions: { ecmaVersion: 2022 } },
+        { code: "class C { static { foo() } }", options: ["never"], parserOptions: { ecmaVersion: 2022 } },
+        { code: "class C { static { foo()\nbar() } }", options: ["never"], parserOptions: { ecmaVersion: 2022 } },
+        { code: "class C { static { foo()\nbar()\nbaz() } }", options: ["never"], parserOptions: { ecmaVersion: 2022 } },
+        { code: "class C { static { foo(); bar() } }", options: ["never"], parserOptions: { ecmaVersion: 2022 } },
+        { code: "class C { static { foo();\n (a) } }", options: ["never"], parserOptions: { ecmaVersion: 2022 } },
+        { code: "class C { static { foo()\n ;(a) } }", options: ["never"], parserOptions: { ecmaVersion: 2022 } },
+        { code: "class C { static { foo();\n [a] } }", options: ["never"], parserOptions: { ecmaVersion: 2022 } },
+        { code: "class C { static { foo()\n ;[a] } }", options: ["never"], parserOptions: { ecmaVersion: 2022 } },
+        { code: "class C { static { foo();\n +a } }", options: ["never"], parserOptions: { ecmaVersion: 2022 } },
+        { code: "class C { static { foo()\n ;+a } }", options: ["never"], parserOptions: { ecmaVersion: 2022 } },
+        { code: "class C { static { foo();\n -a } }", options: ["never"], parserOptions: { ecmaVersion: 2022 } },
+        { code: "class C { static { foo()\n ;-a } }", options: ["never"], parserOptions: { ecmaVersion: 2022 } },
+        { code: "class C { static { foo();\n /a/ } }", options: ["never"], parserOptions: { ecmaVersion: 2022 } },
+        { code: "class C { static { foo()\n ;/a/} }", options: ["never"], parserOptions: { ecmaVersion: 2022 } },
+        {
+            code: "class C { static { foo();\n (a) } }",
+            options: ["never", { beforeStatementContinuationChars: "never" }],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: "class C { static { do ; while (foo)\n (a)} }",
+            options: ["never", { beforeStatementContinuationChars: "never" }],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: "class C { static { do ; while (foo)\n ;(a)} }",
+            options: ["never", { beforeStatementContinuationChars: "always" }],
+            parserOptions: { ecmaVersion: 2022 }
+        },
 
+        // omitLastInOneLineBlock: true
         { code: "if (foo) { bar() }", options: ["always", { omitLastInOneLineBlock: true }] },
         { code: "if (foo) { bar(); baz() }", options: ["always", { omitLastInOneLineBlock: true }] },
+        { code: "if (foo)\n{ bar(); baz() }", options: ["always", { omitLastInOneLineBlock: true }] },
+        { code: "if (foo) {\n bar(); baz(); }", options: ["always", { omitLastInOneLineBlock: true }] },
+        { code: "if (foo) { bar(); baz(); \n}", options: ["always", { omitLastInOneLineBlock: true }] },
+        { code: "function foo() { bar(); baz() }", options: ["always", { omitLastInOneLineBlock: true }] },
+        { code: "function foo()\n{ bar(); baz() }", options: ["always", { omitLastInOneLineBlock: true }] },
+        { code: "function foo(){\n bar(); baz(); }", options: ["always", { omitLastInOneLineBlock: true }] },
+        { code: "function foo(){ bar(); baz(); \n}", options: ["always", { omitLastInOneLineBlock: true }] },
+        { code: "() => { bar(); baz() };", options: ["always", { omitLastInOneLineBlock: true }], parserOptions: { ecmaVersion: 6 } },
+        { code: "() =>\n { bar(); baz() };", options: ["always", { omitLastInOneLineBlock: true }], parserOptions: { ecmaVersion: 6 } },
+        { code: "() => {\n bar(); baz(); };", options: ["always", { omitLastInOneLineBlock: true }], parserOptions: { ecmaVersion: 6 } },
+        { code: "() => { bar(); baz(); \n};", options: ["always", { omitLastInOneLineBlock: true }], parserOptions: { ecmaVersion: 6 } },
+        { code: "const obj = { method() { bar(); baz() } };", options: ["always", { omitLastInOneLineBlock: true }], parserOptions: { ecmaVersion: 6 } },
+        { code: "const obj = { method()\n { bar(); baz() } };", options: ["always", { omitLastInOneLineBlock: true }], parserOptions: { ecmaVersion: 6 } },
+        { code: "const obj = { method() {\n bar(); baz(); } };", options: ["always", { omitLastInOneLineBlock: true }], parserOptions: { ecmaVersion: 6 } },
+        { code: "const obj = { method() { bar(); baz(); \n} };", options: ["always", { omitLastInOneLineBlock: true }], parserOptions: { ecmaVersion: 6 } },
+        { code: "class C {\n method() { bar(); baz() } \n}", options: ["always", { omitLastInOneLineBlock: true }], parserOptions: { ecmaVersion: 6 } },
+        { code: "class C {\n method()\n { bar(); baz() } \n}", options: ["always", { omitLastInOneLineBlock: true }], parserOptions: { ecmaVersion: 6 } },
+        { code: "class C {\n method() {\n bar(); baz(); } \n}", options: ["always", { omitLastInOneLineBlock: true }], parserOptions: { ecmaVersion: 6 } },
+        { code: "class C {\n method() { bar(); baz(); \n} \n}", options: ["always", { omitLastInOneLineBlock: true }], parserOptions: { ecmaVersion: 6 } },
+        { code: "class C {\n static { bar(); baz() } \n}", options: ["always", { omitLastInOneLineBlock: true }], parserOptions: { ecmaVersion: 2022 } },
+        { code: "class C {\n static\n { bar(); baz() } \n}", options: ["always", { omitLastInOneLineBlock: true }], parserOptions: { ecmaVersion: 2022 } },
+        { code: "class C {\n static {\n bar(); baz(); } \n}", options: ["always", { omitLastInOneLineBlock: true }], parserOptions: { ecmaVersion: 2022 } },
+        { code: "class C {\n static { bar(); baz(); \n} \n}", options: ["always", { omitLastInOneLineBlock: true }], parserOptions: { ecmaVersion: 2022 } },
 
-
-        // method definitions don't have a semicolon.
+        // method definitions and static blocks don't have a semicolon.
         { code: "class A { a() {} b() {} }", parserOptions: { ecmaVersion: 6 } },
         { code: "var A = class { a() {} b() {} };", parserOptions: { ecmaVersion: 6 } },
+        { code: "class A { static {} }", parserOptions: { ecmaVersion: 2022 } },
 
         { code: "import theDefault, { named1, named2 } from 'src/mylib';", parserOptions: { ecmaVersion: 6, sourceType: "module" } },
         { code: "import theDefault, { named1, named2 } from 'src/mylib'", options: ["never"], parserOptions: { ecmaVersion: 6, sourceType: "module" } },
@@ -311,6 +370,11 @@ ruleTester.run("semi", rule, {
             options: ["never"],
             parserOptions: { ecmaVersion: 2022 }
         },
+        {
+            code: "class C { static {}; }", // no-extra-semi reports it
+            options: ["never"],
+            parserOptions: { ecmaVersion: 2022 }
+        },
         {
             code: "class C { a=b;\n*foo() {} }",
             options: ["never"],
@@ -990,7 +1054,158 @@ ruleTester.run("semi", rule, {
                 endColumn: 17
             }]
         },
+        {
+            code: "class C { static { foo() } }",
+            output: "class C { static { foo(); } }",
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{
+                messageId: "missingSemi",
+                type: "ExpressionStatement",
+                line: 1,
+                column: 25,
+                endLine: 1,
+                endColumn: 26
+            }]
+        },
+        {
+            code: "class C { static { foo() } }",
+            output: "class C { static { foo(); } }",
+            options: ["always"],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{
+                messageId: "missingSemi",
+                type: "ExpressionStatement",
+                line: 1,
+                column: 25,
+                endLine: 1,
+                endColumn: 26
+            }]
+        },
+        {
+            code: "class C { static { foo(); bar() } }",
+            output: "class C { static { foo(); bar(); } }",
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{
+                messageId: "missingSemi",
+                type: "ExpressionStatement",
+                line: 1,
+                column: 32,
+                endLine: 1,
+                endColumn: 33
+            }]
+        },
+        {
+            code: "class C { static { foo()\nbar(); } }",
+            output: "class C { static { foo();\nbar(); } }",
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{
+                messageId: "missingSemi",
+                type: "ExpressionStatement",
+                line: 1,
+                column: 25,
+                endLine: 2,
+                endColumn: 1
+            }]
+        },
+        {
+            code: "class C { static { foo(); bar()\nbaz(); } }",
+            output: "class C { static { foo(); bar();\nbaz(); } }",
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{
+                messageId: "missingSemi",
+                type: "ExpressionStatement",
+                line: 1,
+                column: 32,
+                endLine: 2,
+                endColumn: 1
+            }]
+        },
+        {
+            code: "class C { static { foo(); } }",
+            output: "class C { static { foo() } }",
+            options: ["never"],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{
+                messageId: "extraSemi",
+                type: "ExpressionStatement",
+                line: 1,
+                column: 25,
+                endLine: 1,
+                endColumn: 26
+            }]
+        },
+        {
+            code: "class C { static { foo();\nbar() } }",
+            output: "class C { static { foo()\nbar() } }",
+            options: ["never"],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{
+                messageId: "extraSemi",
+                type: "ExpressionStatement",
+                line: 1,
+                column: 25,
+                endLine: 1,
+                endColumn: 26
+            }]
+        },
+        {
+            code: "class C { static { foo()\nbar(); } }",
+            output: "class C { static { foo()\nbar() } }",
+            options: ["never"],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{
+                messageId: "extraSemi",
+                type: "ExpressionStatement",
+                line: 2,
+                column: 6,
+                endLine: 2,
+                endColumn: 7
+            }]
+        },
+        {
+            code: "class C { static { foo()\nbar();\nbaz() } }",
+            output: "class C { static { foo()\nbar()\nbaz() } }",
+            options: ["never"],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{
+                messageId: "extraSemi",
+                type: "ExpressionStatement",
+                line: 2,
+                column: 6,
+                endLine: 2,
+                endColumn: 7
+            }]
+        },
+        {
+            code: "class C { static { do ; while (foo)\n (a)} }",
+            output: "class C { static { do ; while (foo);\n (a)} }",
+            options: ["never", { beforeStatementContinuationChars: "always" }],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{
+                messageId: "missingSemi",
+                type: "DoWhileStatement",
+                line: 1,
+                column: 36,
+                endLine: 2,
+                endColumn: 1
+            }]
+        },
+        {
+            code: "class C { static { do ; while (foo)\n ;(a)} }",
+            output: "class C { static { do ; while (foo)\n (a)} }",
+            options: ["never", { beforeStatementContinuationChars: "never" }],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{
+                messageId: "extraSemi",
+                type: "DoWhileStatement",
+                line: 2,
+                column: 2,
+                endLine: 2,
+                endColumn: 3
+            }]
+        },
 
+        // omitLastInOneLineBlock: true
         {
             code: "if (foo) { bar()\n }",
             output: "if (foo) { bar();\n }",
@@ -1039,6 +1254,158 @@ ruleTester.run("semi", rule, {
                 endColumn: 18
             }]
         },
+        {
+            code: "function foo() { bar(); baz(); }",
+            output: "function foo() { bar(); baz() }",
+            options: ["always", { omitLastInOneLineBlock: true }],
+            errors: [{
+                messageId: "extraSemi",
+                line: 1,
+                column: 30,
+                endLine: 1,
+                endColumn: 31
+            }]
+        },
+        {
+            code: "function foo()\n{ bar(); baz(); }",
+            output: "function foo()\n{ bar(); baz() }",
+            options: ["always", { omitLastInOneLineBlock: true }],
+            errors: [{
+                messageId: "extraSemi",
+                line: 2,
+                column: 15,
+                endLine: 2,
+                endColumn: 16
+            }]
+        },
+        {
+            code: "function foo() {\n bar(); baz() }",
+            output: "function foo() {\n bar(); baz(); }",
+            options: ["always", { omitLastInOneLineBlock: true }],
+            errors: [{
+                messageId: "missingSemi",
+                line: 2,
+                column: 14,
+                endLine: 2,
+                endColumn: 15
+            }]
+        },
+        {
+            code: "function foo() { bar(); baz() \n}",
+            output: "function foo() { bar(); baz(); \n}",
+            options: ["always", { omitLastInOneLineBlock: true }],
+            errors: [{
+                messageId: "missingSemi",
+                line: 1,
+                column: 30,
+                endLine: 1,
+                endColumn: 31
+            }]
+        },
+        {
+            code: "class C {\nfoo() { bar(); baz(); }\n}",
+            output: "class C {\nfoo() { bar(); baz() }\n}",
+            options: ["always", { omitLastInOneLineBlock: true }],
+            parserOptions: { ecmaVersion: 6 },
+            errors: [{
+                messageId: "extraSemi",
+                line: 2,
+                column: 21,
+                endLine: 2,
+                endColumn: 22
+            }]
+        },
+        {
+            code: "class C {\nfoo() \n{ bar(); baz(); }\n}",
+            output: "class C {\nfoo() \n{ bar(); baz() }\n}",
+            options: ["always", { omitLastInOneLineBlock: true }],
+            parserOptions: { ecmaVersion: 6 },
+            errors: [{
+                messageId: "extraSemi",
+                line: 3,
+                column: 15,
+                endLine: 3,
+                endColumn: 16
+            }]
+        },
+        {
+            code: "class C {\nfoo() {\n bar(); baz() }\n}",
+            output: "class C {\nfoo() {\n bar(); baz(); }\n}",
+            options: ["always", { omitLastInOneLineBlock: true }],
+            parserOptions: { ecmaVersion: 6 },
+            errors: [{
+                messageId: "missingSemi",
+                line: 3,
+                column: 14,
+                endLine: 3,
+                endColumn: 15
+            }]
+        },
+        {
+            code: "class C {\nfoo() { bar(); baz() \n}\n}",
+            output: "class C {\nfoo() { bar(); baz(); \n}\n}",
+            options: ["always", { omitLastInOneLineBlock: true }],
+            parserOptions: { ecmaVersion: 6 },
+            errors: [{
+                messageId: "missingSemi",
+                line: 2,
+                column: 21,
+                endLine: 2,
+                endColumn: 22
+            }]
+        },
+        {
+            code: "class C {\nstatic { bar(); baz(); }\n}",
+            output: "class C {\nstatic { bar(); baz() }\n}",
+            options: ["always", { omitLastInOneLineBlock: true }],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{
+                messageId: "extraSemi",
+                line: 2,
+                column: 22,
+                endLine: 2,
+                endColumn: 23
+            }]
+        },
+        {
+            code: "class C {\nstatic \n{ bar(); baz(); }\n}",
+            output: "class C {\nstatic \n{ bar(); baz() }\n}",
+            options: ["always", { omitLastInOneLineBlock: true }],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{
+                messageId: "extraSemi",
+                line: 3,
+                column: 15,
+                endLine: 3,
+                endColumn: 16
+            }]
+        },
+        {
+            code: "class C {\nstatic {\n bar(); baz() }\n}",
+            output: "class C {\nstatic {\n bar(); baz(); }\n}",
+            options: ["always", { omitLastInOneLineBlock: true }],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{
+                messageId: "missingSemi",
+                line: 3,
+                column: 14,
+                endLine: 3,
+                endColumn: 15
+            }]
+        },
+        {
+            code: "class C {\nfoo() { bar(); baz() \n}\n}",
+            output: "class C {\nfoo() { bar(); baz(); \n}\n}",
+            options: ["always", { omitLastInOneLineBlock: true }],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{
+                messageId: "missingSemi",
+                line: 2,
+                column: 21,
+                endLine: 2,
+                endColumn: 22
+            }]
+        },
 
 
         // exports, "always"
diff --git a/tests/lib/rules/space-before-blocks.js b/tests/lib/rules/space-before-blocks.js
index 79961dd4d..49af96116 100644
--- a/tests/lib/rules/space-before-blocks.js
+++ b/tests/lib/rules/space-before-blocks.js
@@ -202,7 +202,19 @@ ruleTester.run("space-before-blocks", rule, {
         { code: "switch(x) { case (9):{ break; } }", options: alwaysArgs },
         { code: "switch(x){ case (9): { break; } }", options: neverArgs },
         { code: "switch(x) { default:{ break; } }", options: alwaysArgs },
-        { code: "switch(x){ default: { break; } }", options: neverArgs }
+        { code: "switch(x){ default: { break; } }", options: neverArgs },
+
+        // not conflict with `keyword-spacing`
+        {
+            code: "(class{ static{} })",
+            options: ["always"],
+            parserOptions: { ecmaVersion: 2022 }
+        },
+        {
+            code: "(class { static {} })",
+            options: ["never"],
+            parserOptions: { ecmaVersion: 2022 }
+        }
     ],
     invalid: [
         {
diff --git a/tests/lib/rules/space-unary-ops.js b/tests/lib/rules/space-unary-ops.js
index c56e0135d..ccee19c66 100644
--- a/tests/lib/rules/space-unary-ops.js
+++ b/tests/lib/rules/space-unary-ops.js
@@ -250,6 +250,11 @@ ruleTester.run("space-unary-ops", rule, {
             code: "function *foo () { yield(0) }",
             options: [{ words: false, overrides: { yield: false } }],
             parserOptions: { ecmaVersion: 6 }
+        },
+        {
+            code: "class C { #x; *foo(bar) { yield#x in bar; } }",
+            options: [{ words: false }],
+            parserOptions: { ecmaVersion: 2022 }
         }
     ],
 
@@ -805,6 +810,19 @@ ruleTester.run("space-unary-ops", rule, {
                 line: 1,
                 column: 24
             }]
+        },
+        {
+            code: "class C { #x; *foo(bar) { yield #x in bar; } }",
+            output: "class C { #x; *foo(bar) { yield#x in bar; } }",
+            options: [{ words: false }],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{
+                messageId: "unexpectedAfterWord",
+                data: { word: "yield" },
+                type: "YieldExpression",
+                line: 1,
+                column: 27
+            }]
         }
     ]
 });
diff --git a/tests/lib/rules/strict.js b/tests/lib/rules/strict.js
index def56ace4..e3ea705fe 100644
--- a/tests/lib/rules/strict.js
+++ b/tests/lib/rules/strict.js
@@ -88,7 +88,20 @@ ruleTester.run("strict", rule, {
         "function foo() { 'use strict'; return; }",
         { code: "'use strict'; function foo() { return; }", parserOptions: { ecmaFeatures: { globalReturn: true } } },
         { code: "function foo() { return; }", parserOptions: { ecmaVersion: 6, sourceType: "module" } },
-        { code: "function foo() { return; }", parserOptions: { ecmaFeatures: { impliedStrict: true } } }
+        { code: "function foo() { return; }", parserOptions: { ecmaFeatures: { impliedStrict: true } } },
+
+        // class static blocks do not have directive prologues, therefore this rule should never require od disallow "use strict" statement in them.
+        { code: "'use strict'; class C { static { foo; } }", options: ["global"], parserOptions: { ecmaVersion: 2022 } },
+        { code: "'use strict'; class C { static { 'use strict'; } }", options: ["global"], parserOptions: { ecmaVersion: 2022 } },
+        { code: "'use strict'; class C { static { 'use strict'; 'use strict'; } }", options: ["global"], parserOptions: { ecmaVersion: 2022 } },
+        { code: "class C { static { foo; } }", options: ["function"], parserOptions: { ecmaVersion: 2022 } },
+        { code: "class C { static { 'use strict'; } }", options: ["function"], parserOptions: { ecmaVersion: 2022 } },
+        { code: "class C { static { 'use strict'; 'use strict'; } }", options: ["function"], parserOptions: { ecmaVersion: 2022 } },
+        { code: "class C { static { foo; } }", options: ["never"], parserOptions: { ecmaVersion: 2022 } },
+        { code: "class C { static { 'use strict'; } }", options: ["never"], parserOptions: { ecmaVersion: 2022 } },
+        { code: "class C { static { 'use strict'; 'use strict'; } }", options: ["never"], parserOptions: { ecmaVersion: 2022 } },
+        { code: "class C { static { 'use strict'; } }", options: ["safe"], parserOptions: { ecmaVersion: 2022, sourceType: "module" } },
+        { code: "class C { static { 'use strict'; } }", options: ["safe"], parserOptions: { ecmaVersion: 2022, ecmaFeatures: { impliedStrict: true } } }
 
     ],
     invalid: [
@@ -589,7 +602,60 @@ ruleTester.run("strict", rule, {
             options: ["function"],
             parserOptions: { ecmaVersion: 6 },
             errors: ["Use the function form of 'use strict'."]
-        }
+        },
 
+        // functions inside class static blocks should be checked
+        {
+            code: "'use strict'; class C { static { function foo() { \n'use strict'; } } }",
+            output: null,
+            options: ["global"],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{ messageId: "global", line: 2 }]
+        },
+        {
+            code: "class C { static { function foo() { \n'use strict'; } } }",
+            output: null,
+            options: ["never"],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{ messageId: "never", line: 2 }]
+        },
+        {
+            code: "class C { static { function foo() { \n'use strict'; } } }",
+            output: "class C { static { function foo() { \n } } }",
+            options: ["safe"],
+            parserOptions: { ecmaVersion: 2022, sourceType: "module" },
+            errors: [{ messageId: "module", line: 2 }]
+        },
+        {
+            code: "class C { static { function foo() { \n'use strict'; } } }",
+            output: "class C { static { function foo() { \n } } }",
+            options: ["safe"],
+            parserOptions: { ecmaVersion: 2022, ecmaFeatures: { impliedStrict: true } },
+            errors: [{ messageId: "implied", line: 2 }]
+        },
+        {
+            code: "function foo() {'use strict'; class C { static { function foo() { \n'use strict'; } } } }",
+            output: "function foo() {'use strict'; class C { static { function foo() { \n } } } }",
+            options: ["function"],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{ messageId: "unnecessary", line: 2 }]
+        },
+        {
+            code: "class C { static { function foo() { \n'use strict'; } } }",
+            output: "class C { static { function foo() { \n } } }",
+            options: ["function"],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [{ messageId: "unnecessaryInClasses", line: 2 }]
+        },
+        {
+            code: "class C { static { function foo() { \n'use strict';\n'use strict'; } } }",
+            output: "class C { static { function foo() { \n\n } } }",
+            options: ["function"],
+            parserOptions: { ecmaVersion: 2022 },
+            errors: [
+                { messageId: "unnecessaryInClasses", line: 2 },
+                { messageId: "multiple", line: 3 }
+            ]
+        }
     ]
 });
diff --git a/tests/lib/rules/utils/ast-utils.js b/tests/lib/rules/utils/ast-utils.js
index 0d2954f5b..7789de774 100644
--- a/tests/lib/rules/utils/ast-utils.js
+++ b/tests/lib/rules/utils/ast-utils.js
@@ -1495,7 +1495,10 @@ describe("ast-utils", () => {
             [["(", "123invalidtoken"], false],
             [["(", "1n"], true],
             [["1n", "+"], true],
-            [["1n", "in"], false]
+            [["1n", "in"], false],
+            [["return", "#x"], true],
+            [["yield", "#x"], true],
+            [["get", "#x"], true]
         ]);
 
         CASES.forEach((expectedResult, tokenStrings) => {