Proposal class static block support (#43370)

* Class static block (#9) * Add types factory and parser * Add some case * Make class static block as a container * Update cases * Add visitor * Add emitter and more compile target * Check boundary of break and continue * Add basic transformer * Fix emit behavior * Add more tests * Add friend tests * Update baseline * Fix cr issues * Accept baseline * Add decorator and modifier check * Add functional boundary check * Fix conflict * Fix computed prop name within context * Add more tests * Update baseline * Avoid invalid test baseline * Support use before initialize check * wip * Fix class static block context * Fix checks * Fix missing case * Improve assert message * Accept baseline * Avoid new context * Update diagnostic message * Fix name collision * Fix targets * Avoid unnecessary files * Add more case * Add more test cases * Fix strict mode function declaration * Avoid private fields initializer if no private identifier references * Avoid private fields and add more test case * Add more case * Add tests and support for related services functionality * Fix this reference in static block * Split parser diagnostic and binder diagnostic Co-authored-by: Ron Buckton <ron.buckton@microsoft.com>

Author: Kingwl

src/compiler/binder.ts

@@ -1832,6 +1832,7 @@ namespace ts {
  case SyntaxKind.ConstructSignature:
  case SyntaxKind.IndexSignature:
  case SyntaxKind.ConstructorType:
+ case SyntaxKind.ClassStaticBlockDeclaration:
  return ContainerFlags.IsContainer | ContainerFlags.IsControlFlowContainer | ContainerFlags.HasLocals | ContainerFlags.IsFunctionLike;
 
  case SyntaxKind.FunctionExpression:
@@ -1867,7 +1868,7 @@ namespace ts {
  // By not creating a new block-scoped-container here, we ensure that both 'var x'
  // and 'let x' go into the Function-container's locals, and we do get a collision
  // conflict.
- return isFunctionLike(node.parent) ? ContainerFlags.None : ContainerFlags.IsBlockScopedContainer;
+ return isFunctionLike(node.parent) || isClassStaticBlockDeclaration(node.parent) ? ContainerFlags.None : ContainerFlags.IsBlockScopedContainer;
  }
 
  return ContainerFlags.None;
@@ -1929,6 +1930,7 @@ namespace ts {
  case SyntaxKind.JSDocFunctionType:
  case SyntaxKind.JSDocTypedefTag:
  case SyntaxKind.JSDocCallbackTag:
+ case SyntaxKind.ClassStaticBlockDeclaration:
  case SyntaxKind.TypeAliasDeclaration:
  case SyntaxKind.MappedType:
  // All the children of these container types are never visible through another
@@ -2328,7 +2330,7 @@ namespace ts {
  // Report error if function is not top level function declaration
  if (blockScopeContainer.kind !== SyntaxKind.SourceFile &&
  blockScopeContainer.kind !== SyntaxKind.ModuleDeclaration &&
- !isFunctionLike(blockScopeContainer)) {
+ !isFunctionLikeOrClassStaticBlockDeclaration(blockScopeContainer)) {
  // We check first if the name is inside class declaration or class expression; if so give explicit message
  // otherwise report generic error message.
  const errorSpan = getErrorSpanForNode(file, node);
@@ -2712,7 +2714,7 @@ namespace ts {
  updateStrictModeStatementList((node as SourceFile).statements);
  return bindSourceFileIfExternalModule();
  case SyntaxKind.Block:
- if (!isFunctionLike(node.parent)) {
+ if (!isFunctionLikeOrClassStaticBlockDeclaration(node.parent)) {
  return;
  }
  // falls through

src/compiler/checker.ts

@@ -24186,7 +24186,7 @@ namespace ts {
  // To avoid that we will give an error to users if they use arguments objects in arrow function so that they
  // can explicitly bound arguments objects
  if (symbol === argumentsSymbol) {
- if (isInPropertyInitializer(node)) {
+ if (isInPropertyInitializerOrClassStaticBlock(node)) {
  error(node, Diagnostics.arguments_cannot_be_referenced_in_property_initializers);
  return errorType;
  }
@@ -24544,6 +24544,9 @@ namespace ts {
  // do not return here so in case if lexical this is captured - it will be reflected in flags on NodeLinks
  }
  break;
+ case SyntaxKind.ClassStaticBlockDeclaration:
+ error(node, Diagnostics.this_cannot_be_referenced_in_current_location);
+ break;
  case SyntaxKind.ComputedPropertyName:
  error(node, Diagnostics.this_cannot_be_referenced_in_a_computed_property_name);
  break;
@@ -24602,7 +24605,8 @@ namespace ts {
 
  if (isClassLike(container.parent)) {
  const symbol = getSymbolOfNode(container.parent);
- const type = hasSyntacticModifier(container, ModifierFlags.Static) ? getTypeOfSymbol(symbol) : (getDeclaredTypeOfSymbol(symbol) as InterfaceType).thisType!;
+ const isStatic = hasSyntacticModifier(container, ModifierFlags.Static) || isClassStaticBlockDeclaration(container);
+ const type = isStatic ? getTypeOfSymbol(symbol) : (getDeclaredTypeOfSymbol(symbol) as InterfaceType).thisType!;
  return getFlowTypeOfReference(node, type);
  }
 
@@ -27565,7 +27569,7 @@ namespace ts {
 
  let diagnosticMessage;
  const declarationName = idText(right);
- if (isInPropertyInitializer(node)
+ if (isInPropertyInitializerOrClassStaticBlock(node)
  && !isOptionalPropertyDeclaration(valueDeclaration)
  && !(isAccessExpression(node) && isAccessExpression(node.expression))
  && !isBlockScopedNameDeclaredBeforeUse(valueDeclaration, right)
@@ -27586,7 +27590,7 @@ namespace ts {
  }
  }
 
- function isInPropertyInitializer(node: Node): boolean {
+ function isInPropertyInitializerOrClassStaticBlock(node: Node): boolean {
  return !!findAncestor(node, node => {
  switch (node.kind) {
  case SyntaxKind.PropertyDeclaration:
@@ -27606,6 +27610,8 @@ namespace ts {
  case SyntaxKind.ExpressionWithTypeArguments:
  case SyntaxKind.HeritageClause:
  return false;
+ case SyntaxKind.ExpressionStatement:
+ return isBlock(node.parent) && isClassStaticBlockDeclaration(node.parent.parent) ? true : "quit";
  default:
  return isExpressionNode(node) ? false : "quit";
  }
@@ -31303,7 +31309,11 @@ namespace ts {
  function checkAwaitExpression(node: AwaitExpression): Type {
  // Grammar checking
  if (produceDiagnostics) {
- if (!(node.flags & NodeFlags.AwaitContext)) {
+ const container = getContainingFunctionOrClassStaticBlock(node);
+ if (container && isClassStaticBlockDeclaration(container)) {
+ error(node, Diagnostics.Await_expression_cannot_be_used_inside_a_class_static_block);
+ }
+ else if (!(node.flags & NodeFlags.AwaitContext)) {
  if (isInTopLevelContext(node)) {
  const sourceFile = getSourceFileOfNode(node);
  if (!hasParseDiagnostics(sourceFile)) {
@@ -31328,9 +31338,8 @@ namespace ts {
  if (!hasParseDiagnostics(sourceFile)) {
  const span = getSpanOfTokenAtPosition(sourceFile, node.pos);
  const diagnostic = createFileDiagnostic(sourceFile, span.start, span.length, Diagnostics.await_expressions_are_only_allowed_within_async_functions_and_at_the_top_levels_of_modules);
- const func = getContainingFunction(node);
- if (func && func.kind !== SyntaxKind.Constructor && (getFunctionFlags(func) & FunctionFlags.Async) === 0) {
- const relatedInfo = createDiagnosticForNode(func, Diagnostics.Did_you_mean_to_mark_this_function_as_async);
+ if (container && container.kind !== SyntaxKind.Constructor && (getFunctionFlags(container) & FunctionFlags.Async) === 0) {
+ const relatedInfo = createDiagnosticForNode(container, Diagnostics.Did_you_mean_to_mark_this_function_as_async);
  addRelatedInfo(diagnostic, relatedInfo);
  }
  diagnostics.add(diagnostic);
@@ -33489,6 +33498,12 @@ namespace ts {
  }
  }
 
+ function checkClassStaticBlockDeclaration(node: ClassStaticBlockDeclaration) {
+ checkGrammarDecoratorsAndModifiers(node);
+
+ forEachChild(node, checkSourceElement);
+ }
+
  function checkConstructorDeclaration(node: ConstructorDeclaration) {
  // Grammar check on signature of constructor and modifier of the constructor is done in checkSignatureDeclaration function.
  checkSignatureDeclaration(node);
@@ -35096,10 +35111,11 @@ namespace ts {
  break;
  case SyntaxKind.IndexSignature:
  case SyntaxKind.SemicolonClassElement:
+ case SyntaxKind.ClassStaticBlockDeclaration:
  // Can't be private
  break;
  default:
- Debug.fail();
+ Debug.fail("Unexpected class member");
  }
  }
  }
@@ -35531,6 +35547,7 @@ namespace ts {
  if (!node.name) {
  return;
  }
+
  // For a computed property, just check the initializer and exit
  // Do not use hasDynamicName here, because that returns false for well known symbols.
  // We want to perform checkComputedPropertyName for all computed properties, including
@@ -35907,11 +35924,17 @@ namespace ts {
  function checkForOfStatement(node: ForOfStatement): void {
  checkGrammarForInOrForOfStatement(node);
 
+ const container = getContainingFunctionOrClassStaticBlock(node);
  if (node.awaitModifier) {
- const functionFlags = getFunctionFlags(getContainingFunction(node));
- if ((functionFlags & (FunctionFlags.Invalid | FunctionFlags.Async)) === FunctionFlags.Async && languageVersion < ScriptTarget.ESNext) {
- // for..await..of in an async function or async generator function prior to ESNext requires the __asyncValues helper
- checkExternalEmitHelpers(node, ExternalEmitHelpers.ForAwaitOfIncludes);
+ if (container && isClassStaticBlockDeclaration(container)) {
+ grammarErrorOnNode(node.awaitModifier, Diagnostics.For_await_loops_cannot_be_used_inside_a_class_static_block);
+ }
+ else {
+ const functionFlags = getFunctionFlags(container);
+ if ((functionFlags & (FunctionFlags.Invalid | FunctionFlags.Async)) === FunctionFlags.Async && languageVersion < ScriptTarget.ESNext) {
+ // for..await..of in an async function or async generator function prior to ESNext requires the __asyncValues helper
+ checkExternalEmitHelpers(node, ExternalEmitHelpers.ForAwaitOfIncludes);
+ }
  }
  }
  else if (compilerOptions.downlevelIteration && languageVersion < ScriptTarget.ES2015) {
@@ -36791,28 +36814,33 @@ namespace ts {
  return;
  }
 
- const func = getContainingFunction(node);
- if (!func) {
+ const container = getContainingFunctionOrClassStaticBlock(node);
+ if(container && isClassStaticBlockDeclaration(container)) {
+ grammarErrorOnFirstToken(node, Diagnostics.A_return_statement_cannot_be_used_inside_a_class_static_block);
+ return;
+ }
+
+ if (!container) {
  grammarErrorOnFirstToken(node, Diagnostics.A_return_statement_can_only_be_used_within_a_function_body);
  return;
  }
 
- const signature = getSignatureFromDeclaration(func);
+ const signature = getSignatureFromDeclaration(container);
  const returnType = getReturnTypeOfSignature(signature);
- const functionFlags = getFunctionFlags(func);
+ const functionFlags = getFunctionFlags(container);
  if (strictNullChecks || node.expression || returnType.flags & TypeFlags.Never) {
  const exprType = node.expression ? checkExpressionCached(node.expression) : undefinedType;
- if (func.kind === SyntaxKind.SetAccessor) {
+ if (container.kind === SyntaxKind.SetAccessor) {
  if (node.expression) {
  error(node, Diagnostics.Setters_cannot_return_a_value);
  }
  }
- else if (func.kind === SyntaxKind.Constructor) {
+ else if (container.kind === SyntaxKind.Constructor) {
  if (node.expression && !checkTypeAssignableToAndOptionallyElaborate(exprType, returnType, node, node.expression)) {
  error(node, Diagnostics.Return_type_of_constructor_signature_must_be_assignable_to_the_instance_type_of_the_class);
  }
  }
- else if (getReturnTypeFromAnnotation(func)) {
+ else if (getReturnTypeFromAnnotation(container)) {
  const unwrappedReturnType = unwrapReturnType(returnType, functionFlags) ?? returnType;
  const unwrappedExprType = functionFlags & FunctionFlags.Async
  ? checkAwaitedType(exprType, node, Diagnostics.The_return_type_of_an_async_function_must_either_be_a_valid_promise_or_must_not_contain_a_callable_then_member)
@@ -36825,7 +36853,7 @@ namespace ts {
  }
  }
  }
- else if (func.kind !== SyntaxKind.Constructor && compilerOptions.noImplicitReturns && !isUnwrappedReturnTypeVoidOrAny(func, returnType)) {
+ else if (container.kind !== SyntaxKind.Constructor && compilerOptions.noImplicitReturns && !isUnwrappedReturnTypeVoidOrAny(container, returnType)) {
  // The function has a return type, but the return statement doesn't have an expression.
  error(node, Diagnostics.Not_all_code_paths_return_a_value);
  }
@@ -38655,6 +38683,8 @@ namespace ts {
  case SyntaxKind.MethodDeclaration:
  case SyntaxKind.MethodSignature:
  return checkMethodDeclaration(node as MethodDeclaration | MethodSignature);
+ case SyntaxKind.ClassStaticBlockDeclaration:
+ return checkClassStaticBlockDeclaration(node as ClassStaticBlockDeclaration);
  case SyntaxKind.Constructor:
  return checkConstructorDeclaration(node as ConstructorDeclaration);
  case SyntaxKind.GetAccessor:
@@ -41132,6 +41162,7 @@ namespace ts {
  case SyntaxKind.InterfaceDeclaration:
  case SyntaxKind.VariableStatement:
  case SyntaxKind.TypeAliasDeclaration:
+ case SyntaxKind.ClassStaticBlockDeclaration:
  return true;
  case SyntaxKind.EnumDeclaration:
  return nodeHasAnyModifiersExcept(node, SyntaxKind.ConstKeyword);
@@ -41869,7 +41900,7 @@ namespace ts {
  function checkGrammarBreakOrContinueStatement(node: BreakOrContinueStatement): boolean {
  let current: Node = node;
  while (current) {
- if (isFunctionLike(current)) {
+ if (isFunctionLikeOrClassStaticBlockDeclaration(current)) {
  return grammarErrorOnNode(node, Diagnostics.Jump_target_cannot_cross_function_boundary);
  }
 

src/compiler/diagnosticMessages.json

@@ -7154,5 +7154,21 @@
  "Class decorators can't be used with static private identifier. Consider removing the experimental decorator.": {
  "category": "Error",
  "code": 18036
+ },
+ "Await expression cannot be used inside a class static block.": {
+ "category": "Error",
+ "code": 18037
+ },
+ "'For await' loops cannot be used inside a class static block.": {
+ "category": "Error",
+ "code": 18038
+ },
+ "Invalid use of '{0}'. It cannot be used inside a class static block.": {
+ "category": "Error",
+ "code": 18039
+ },
+ "A 'return' statement cannot be used inside a class static block.": {
+ "category": "Error",
+ "code": 18041
  }
 }

src/compiler/emitter.ts

@@ -1351,6 +1351,8 @@ namespace ts {
  return emitMethodSignature(node as MethodSignature);
  case SyntaxKind.MethodDeclaration:
  return emitMethodDeclaration(node as MethodDeclaration);
+ case SyntaxKind.ClassStaticBlockDeclaration:
+ return emitClassStaticBlockDeclaration(node as ClassStaticBlockDeclaration);
  case SyntaxKind.Constructor:
  return emitConstructor(node as ConstructorDeclaration);
  case SyntaxKind.GetAccessor:
@@ -2063,6 +2065,13 @@ namespace ts {
  emitSignatureAndBody(node, emitSignatureHead);
  }
 
+ function emitClassStaticBlockDeclaration(node: ClassStaticBlockDeclaration) {
+ emitDecorators(node, node.decorators);
+ emitModifiers(node, node.modifiers);
+ writeKeyword("static");
+ emitBlockFunctionBody(node.body);
+ }
+
  function emitConstructor(node: ConstructorDeclaration) {
  emitModifiers(node, node.modifiers);
  writeKeyword("constructor");

src/compiler/factory/nodeFactory.ts

@@ -94,6 +94,8 @@ namespace ts {
  updateConstructSignature,
  createIndexSignature,
  updateIndexSignature,
+ createClassStaticBlockDeclaration,
+ updateClassStaticBlockDeclaration,
  createTemplateLiteralTypeSpan,
  updateTemplateLiteralTypeSpan,
  createKeywordTypeNode,
@@ -1415,6 +1417,38 @@ namespace ts {
  : node;
  }
 
+ // @api
+ function createClassStaticBlockDeclaration(
+ decorators: readonly Decorator[] | undefined,
+ modifiers: readonly Modifier[] | undefined,
+ body: Block
+ ): ClassStaticBlockDeclaration {
+ const node = createBaseGenericNamedDeclaration<ClassStaticBlockDeclaration>(
+ SyntaxKind.ClassStaticBlockDeclaration,
+ decorators,
+ modifiers,
+ /*name*/ undefined,
+ /*typeParameters*/ undefined
+ );
+ node.body = body;
+ node.transformFlags = propagateChildFlags(body) | TransformFlags.ContainsClassFields;
+ return node;
+ }
+
+ // @api
+ function updateClassStaticBlockDeclaration(
+ node: ClassStaticBlockDeclaration,
+ decorators: readonly Decorator[] | undefined,
+ modifiers: readonly Modifier[] | undefined,
+ body: Block
+ ): ClassStaticBlockDeclaration {
+ return node.decorators !== decorators
+ || node.modifier !== modifiers
+ || node.body !== body
+ ? update(createClassStaticBlockDeclaration(decorators, modifiers, body), node)
+ : node;
+ }
+
  // @api
  function createConstructorDeclaration(
  decorators: readonly Decorator[] | undefined,

src/compiler/factory/nodeTests.ts

@@ -182,6 +182,10 @@ namespace ts {
  return node.kind === SyntaxKind.MethodDeclaration;
  }
 
+ export function isClassStaticBlockDeclaration(node: Node): node is ClassStaticBlockDeclaration {
+ return node.kind === SyntaxKind.ClassStaticBlockDeclaration;
+ }
+
  export function isConstructorDeclaration(node: Node): node is ConstructorDeclaration {
  return node.kind === SyntaxKind.Constructor;
  }