align ClassStaticBlockDeclaration with IIFE in CFA

src/compiler/binder.ts

@@ -657,19 +657,23 @@ namespace ts {
                 const saveExceptionTarget = currentExceptionTarget;
                 const saveActiveLabelList = activeLabelList;
                 const saveHasExplicitReturn = hasExplicitReturn;
-                const isIIFE = containerFlags & ContainerFlags.IsFunctionExpression && !hasSyntacticModifier(node, ModifierFlags.Async) &&
-                    !(node as FunctionLikeDeclaration).asteriskToken && !!getImmediatelyInvokedFunctionExpression(node);
+                const isIIFELike =
+                    (containerFlags & ContainerFlags.IsFunctionExpression &&
+                        !hasSyntacticModifier(node, ModifierFlags.Async) &&
+                        !(node as FunctionLikeDeclaration).asteriskToken &&
+                        !!getImmediatelyInvokedFunctionExpression(node)) ||
+                    node.kind === SyntaxKind.ClassStaticBlockDeclaration;
                 // A non-async, non-generator IIFE is considered part of the containing control flow. Return statements behave
                 // similarly to break statements that exit to a label just past the statement body.
-                if (!isIIFE) {
+                if (!isIIFELike) {
                     currentFlow = initFlowNode({ flags: FlowFlags.Start });
                     if (containerFlags & (ContainerFlags.IsFunctionExpression | ContainerFlags.IsObjectLiteralOrClassExpressionMethod)) {
                         currentFlow.node = node as FunctionExpression | ArrowFunction | MethodDeclaration;
                     }
                 }
                 // We create a return control flow graph for IIFEs and constructors. For constructors
                 // we use the return control flow graph in strict property initialization checks.
-                currentReturnTarget = isIIFE || node.kind === SyntaxKind.Constructor || node.kind === SyntaxKind.ClassStaticBlockDeclaration || (isInJSFile(node) && (node.kind === SyntaxKind.FunctionDeclaration || node.kind === SyntaxKind.FunctionExpression)) ? createBranchLabel() : undefined;
+                currentReturnTarget = isIIFELike || node.kind === SyntaxKind.Constructor || (isInJSFile(node) && (node.kind === SyntaxKind.FunctionDeclaration || node.kind === SyntaxKind.FunctionExpression)) ? createBranchLabel() : undefined;
                 currentExceptionTarget = undefined;
                 currentBreakTarget = undefined;
                 currentContinueTarget = undefined;
@@ -695,7 +699,7 @@ namespace ts {
                         (node as FunctionLikeDeclaration | ClassStaticBlockDeclaration).returnFlowNode = currentFlow;
                     }
                 }
-                if (!isIIFE) {
+                if (!isIIFELike) {
                     currentFlow = saveCurrentFlow;
                 }
                 currentBreakTarget = saveBreakTarget;

tests/baselines/reference/classStaticBlock28.js

@@ -0,0 +1,23 @@
+//// [classStaticBlock28.ts]
+let foo: number;
+
+class C {
+    static {
+        foo = 1
+    }
+}
+
+console.log(foo)
+
+//// [classStaticBlock28.js]
+"use strict";
+var foo;
+var C = /** @class */ (function () {
+    function C() {
+    }
+    return C;
+}());
+(function () {
+    foo = 1;
+})();
+console.log(foo);

tests/baselines/reference/classStaticBlock28.symbols

@@ -0,0 +1,19 @@
+=== tests/cases/conformance/classes/classStaticBlock/classStaticBlock28.ts ===
+let foo: number;
+>foo : Symbol(foo, Decl(classStaticBlock28.ts, 0, 3))
+
+class C {
+>C : Symbol(C, Decl(classStaticBlock28.ts, 0, 16))
+
+    static {
+        foo = 1
+>foo : Symbol(foo, Decl(classStaticBlock28.ts, 0, 3))
+    }
+}
+
+console.log(foo)
+>console.log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --))
+>console : Symbol(console, Decl(lib.dom.d.ts, --, --))
+>log : Symbol(Console.log, Decl(lib.dom.d.ts, --, --))
+>foo : Symbol(foo, Decl(classStaticBlock28.ts, 0, 3))
+

tests/baselines/reference/classStaticBlock28.types

@@ -0,0 +1,22 @@
+=== tests/cases/conformance/classes/classStaticBlock/classStaticBlock28.ts ===
+let foo: number;
+>foo : number
+
+class C {
+>C : C
+
+    static {
+        foo = 1
+>foo = 1 : 1
+>foo : number
+>1 : 1
+    }
+}
+
+console.log(foo)
+>console.log(foo) : void
+>console.log : (...data: any[]) => void
+>console : Console
+>log : (...data: any[]) => void
+>foo : number
+

tests/cases/conformance/classes/classStaticBlock/classStaticBlock28.ts

@@ -0,0 +1,11 @@
+// @strict: true
+
+let foo: number;
+
+class C {
+    static {
+        foo = 1
+    }
+}
+
+console.log(foo)