tsc-ts 0.0.4 → 0.0.5

package/src/compiler/checker-statements.ts

@@ -0,0 +1,292 @@
+// Statements.
+import {
+  type CaseOrDefaultClause,
+  type CatchClause,
+  type DoStatement,
+  type ForInOrOfStatement,
+  type ForStatement,
+  type IfStatement,
+  type LabeledStatement,
+  type Node,
+  type ReturnStatement,
+  type SwitchStatement,
+  type TryStatement,
+  type VariableDeclarationList,
+  type WhileStatement,
+  getExpression,
+  getStatements,
+  getName,
+  NodeFlags,
+} from './ast.js';
+import { Diagnostics } from './diagnostics.js';
+import { SyntaxKind } from './syntax-kind.js';
+import { type Checker, createDiagnosticForNode } from './checker.js';
+import { CheckMode, type Type, TypeFlags } from './checker-types.js';
+import {
+  getReturnTypeFromAnnotation,
+  getReturnTypeOfSignature,
+  getSignatureFromDeclaration,
+} from './checker-signatures.js';
+import {
+  checkExpression,
+  checkExpressionCached,
+  checkNonNullExpression,
+  checkTypeAssignableToAndOptionallyElaborate,
+} from './checker-expressions.js';
+import { IterationUse, checkIteratedTypeOrElementType } from './checker-iteration.js';
+import { checkDestructuringAssignment } from './checker-destructuring.js';
+import {
+  checkReferenceExpression,
+  checkTestingKnownTruthyType,
+  checkTruthinessExpression,
+  isTypeEqualityComparableTo,
+} from './checker-operators.js';
+import { checkTypeComparableTo, isTypeAssignableTo } from './relations.js';
+import { isReachableFlowNode } from './checker-narrowing.js';
+import { getIndexType, isTypeAssignableToKindEx as isTypeAssignableToKind } from './checker-type-operators.js';
+import { getExtractStringType } from './checker-symbol-types.js';
+import { checkSourceElement } from './checker-source-file.js';
+import { checkVariableDeclarationList, checkVariableLikeDeclaration } from './checker-declarations.js';
+import { checkReturnExpression, isUnwrappedReturnTypeUndefinedVoidOrAny } from './checker-functions.js';
+import { unwrapReturnType } from './checker-iteration.js';
+import { FunctionFlags, getFunctionFlags, isBindingPattern } from './checker-utilities.js';
+import { getContainingFunctionOrClassStaticBlock } from './checker-grammar.js';
+import { ScriptTarget } from './options.js';
+import { ExternalEmitHelpers, checkExternalEmitHelpers } from './checker-emit-helpers.js';
+import { typeToString } from './type-printer.js';
+import { TypeFacts, getNonNullableType, hasTypeFacts } from './checker-flow.js';
+
+export function checkBlock(c: Checker, node: Node): void {
+  for (const s of getStatements(node)!.nodes) checkSourceElement(c, s);
+}
+
+export function checkExpressionStatement(c: Checker, node: Node): void {
+  checkExpression(c, getExpression(node)!);
+}
+
+export function checkIfStatement(c: Checker, node: Node): void {
+  const s = node as IfStatement;
+  const t = checkTruthinessExpression(c, s.expression, CheckMode.Normal);
+  checkTestingKnownTruthyType(c, s.expression, t, s.thenStatement);
+  checkSourceElement(c, s.thenStatement);
+  if (s.thenStatement.kind === SyntaxKind.EmptyStatement)
+    c.error(s.thenStatement, Diagnostics.The_body_of_an_if_statement_cannot_be_the_empty_statement);
+  checkSourceElement(c, s.elseStatement);
+}
+
+export function checkDoStatement(c: Checker, node: Node): void {
+  const s = node as DoStatement;
+  checkSourceElement(c, s.statement);
+  checkTruthinessExpression(c, s.expression, CheckMode.Normal);
+}
+
+export function checkWhileStatement(c: Checker, node: Node): void {
+  const s = node as WhileStatement;
+  checkTruthinessExpression(c, s.expression, CheckMode.Normal);
+  checkSourceElement(c, s.statement);
+}
+
+export function checkForStatement(c: Checker, node: Node): void {
+  const s = node as ForStatement;
+  const initializer = s.initializer;
+  if (initializer !== undefined) {
+    if (initializer.kind === SyntaxKind.VariableDeclarationList) checkVariableDeclarationList(c, initializer);
+    else checkExpression(c, initializer);
+  }
+  if (s.condition !== undefined) checkTruthinessExpression(c, s.condition, CheckMode.Normal);
+  if (s.incrementor !== undefined) checkExpression(c, s.incrementor);
+  checkSourceElement(c, s.statement);
+}
+
+export function checkForInStatement(c: Checker, node: Node): void {
+  const s = node as ForInOrOfStatement;
+  const expressionType = checkExpression(c, s.expression);
+  const rightType = hasTypeFacts(c, expressionType, TypeFacts.IsUndefinedOrNull)
+    ? getNonNullableType(c, expressionType)
+    : expressionType;
+  if (s.initializer.kind === SyntaxKind.VariableDeclarationList) {
+    const declarations = (s.initializer as VariableDeclarationList).declarations.nodes;
+    if (declarations.length !== 0 && isBindingPattern(getName(declarations[0]!)))
+      c.error(
+        getName(declarations[0]!)!,
+        Diagnostics.The_left_hand_side_of_a_for_in_statement_cannot_be_a_destructuring_pattern,
+      );
+    for (const d of declarations) checkVariableLikeDeclaration(c, d);
+  } else {
+    // The variable must be a reference that the keys of the object, as strings, are assignable to.
+    const varExpr = s.initializer;
+    const leftType = checkExpression(c, varExpr);
+    if (varExpr.kind === SyntaxKind.ArrayLiteralExpression || varExpr.kind === SyntaxKind.ObjectLiteralExpression)
+      c.error(varExpr, Diagnostics.The_left_hand_side_of_a_for_in_statement_cannot_be_a_destructuring_pattern);
+    else if (!isTypeAssignableTo(c, getIndexTypeOrString(c, rightType), leftType))
+      c.error(varExpr, Diagnostics.The_left_hand_side_of_a_for_in_statement_must_be_of_type_string_or_any);
+    else
+      checkReferenceExpression(
+        c,
+        varExpr,
+        Diagnostics.The_left_hand_side_of_a_for_in_statement_must_be_a_variable_or_a_property_access,
+        Diagnostics.The_left_hand_side_of_a_for_in_statement_may_not_be_an_optional_property_access,
+      );
+  }
+  if (
+    (rightType.flags & TypeFlags.Never) !== 0 ||
+    !isTypeAssignableToKind(c, rightType, TypeFlags.NonPrimitive | TypeFlags.InstantiableNonPrimitive, false)
+  )
+    c.error(
+      s.expression,
+      Diagnostics.The_right_hand_side_of_a_for_in_statement_must_be_of_type_any_an_object_type_or_a_type_parameter_but_here_has_type_0,
+      typeToString(c, rightType),
+    );
+  checkSourceElement(c, s.statement);
+}
+
+function getIndexTypeOrString(c: Checker, t: Type): Type {
+  const indexType = getExtractStringType(c, getIndexType(c, t));
+  return (indexType.flags & TypeFlags.Never) !== 0 ? c.stringType : indexType;
+}
+
+export function checkForOfStatement(c: Checker, node: Node): void {
+  const s = node as ForInOrOfStatement;
+  // for await..of in an async function before ES2018 uses __asyncValues.
+  if (s.awaitModifier !== undefined) {
+    const container = getContainingFunctionOrClassStaticBlock(node);
+    if (
+      (container === undefined || container.kind !== SyntaxKind.ClassStaticBlockDeclaration) &&
+      (getFunctionFlags(container) & (FunctionFlags.Invalid | FunctionFlags.Async)) === FunctionFlags.Async &&
+      c.languageVersion < ScriptTarget.ES2018
+    )
+      checkExternalEmitHelpers(c, node, ExternalEmitHelpers.ForAwaitOfIncludes);
+  }
+  // A declaration checks the right side through its type; an expression is checked as a
+  // destructuring assignment or a reference the iterated type must be assignable to.
+  if (s.initializer.kind === SyntaxKind.VariableDeclarationList) {
+    for (const d of (s.initializer as VariableDeclarationList).declarations.nodes) checkVariableLikeDeclaration(c, d);
+  } else {
+    const varExpr = s.initializer;
+    const iteratedType = checkRightHandSideOfForOf(c, s);
+    if (varExpr.kind === SyntaxKind.ArrayLiteralExpression || varExpr.kind === SyntaxKind.ObjectLiteralExpression)
+      checkDestructuringAssignment(c, varExpr, iteratedType, CheckMode.Normal, false);
+    else {
+      const leftType = checkExpression(c, varExpr);
+      checkReferenceExpression(
+        c,
+        varExpr,
+        Diagnostics.The_left_hand_side_of_a_for_of_statement_must_be_a_variable_or_a_property_access,
+        Diagnostics.The_left_hand_side_of_a_for_of_statement_may_not_be_an_optional_property_access,
+      );
+      checkTypeAssignableToAndOptionallyElaborate(c, iteratedType, leftType, varExpr, s.expression);
+    }
+  }
+  checkSourceElement(c, s.statement);
+}
+
+/** The element type a `for...of` produces. */
+export function checkRightHandSideOfForOf(c: Checker, statement: Node): Type {
+  const s = statement as ForInOrOfStatement;
+  const use = s.awaitModifier !== undefined ? IterationUse.ForAwaitOf : IterationUse.ForOf;
+  return checkIteratedTypeOrElementType(c, use, checkNonNullExpression(c, s.expression), c.undefinedType, s.expression);
+}
+
+export function checkReturnStatement(c: Checker, node: Node): void {
+  const s = node as ReturnStatement;
+  const container = getContainingFunction(node);
+  // Returns outside functions and in static blocks are grammar errors.
+  if (container === undefined) return;
+  const signature = getSignatureFromDeclaration(c, container);
+  const returnType = getReturnTypeOfSignature(c, signature);
+  const functionFlags = getFunctionFlags(container);
+  const exprNode = s.expression;
+  if (c.strictNullChecks || exprNode !== undefined || (returnType.flags & TypeFlags.Never) !== 0) {
+    const exprType = exprNode !== undefined ? checkExpressionCached(c, exprNode) : c.undefinedType;
+    if (container.kind === SyntaxKind.SetAccessor) {
+      if (exprNode !== undefined) c.error(node, Diagnostics.Setters_cannot_return_a_value);
+    } else if (container.kind === SyntaxKind.Constructor) {
+      if (
+        exprNode !== undefined &&
+        !checkTypeAssignableToAndOptionallyElaborate(c, exprType, returnType, node, exprNode)
+      )
+        c.error(
+          node,
+          Diagnostics.Return_type_of_constructor_signature_must_be_assignable_to_the_instance_type_of_the_class,
+        );
+    } else if (getReturnTypeFromAnnotation(c, container) !== undefined) {
+      const unwrappedReturnType = unwrapReturnType(c, returnType, functionFlags);
+      checkReturnExpression(c, container, unwrappedReturnType, node, exprNode, exprType, false);
+    }
+  } else if (
+    container.kind !== SyntaxKind.Constructor &&
+    c.compilerOptions.noImplicitReturns === true &&
+    !isUnwrappedReturnTypeUndefinedVoidOrAny(c, container, returnType)
+  )
+    // The function has a return type, but this return statement has no expression.
+    c.error(node, Diagnostics.Not_all_code_paths_return_a_value);
+}
+
+function getContainingFunction(node: Node): Node | undefined {
+  let current = node.parent;
+  while (current !== undefined) {
+    switch (current.kind) {
+      case SyntaxKind.FunctionDeclaration:
+      case SyntaxKind.FunctionExpression:
+      case SyntaxKind.ArrowFunction:
+      case SyntaxKind.MethodDeclaration:
+      case SyntaxKind.GetAccessor:
+      case SyntaxKind.SetAccessor:
+      case SyntaxKind.Constructor:
+        return current;
+      case SyntaxKind.ClassStaticBlockDeclaration:
+      case SyntaxKind.SourceFile:
+        return undefined;
+    }
+    current = current.parent;
+  }
+  return undefined;
+}
+
+export function checkSwitchStatement(c: Checker, node: Node): void {
+  const s = node as SwitchStatement;
+  const expressionType = checkExpression(c, s.expression);
+  for (const clause of s.caseBlock.clauses.nodes) {
+    const caseClause = clause as CaseOrDefaultClause;
+    if (caseClause.expression !== undefined) {
+      const caseType = checkExpression(c, caseClause.expression);
+      // Without equality comparability, the reversed comparison reports the error.
+      if (!isTypeEqualityComparableTo(c, expressionType, caseType))
+        checkTypeComparableTo(c, caseType, expressionType, caseClause.expression, undefined);
+    }
+    for (const statement of caseClause.statements.nodes) checkSourceElement(c, statement);
+    if (
+      c.compilerOptions.noFallthroughCasesInSwitch === true &&
+      caseClause.fallthroughFlowNode !== undefined &&
+      isReachableFlowNode(c, caseClause.fallthroughFlowNode)
+    )
+      c.error(clause, Diagnostics.Fallthrough_case_in_switch);
+  }
+}
+
+export function checkLabeledStatement(c: Checker, node: Node): void {
+  const { label, statement } = node as LabeledStatement;
+  // The binder marks the labels that no break or continue statement references.
+  if ((label.flags & NodeFlags.Unreachable) !== 0 && c.compilerOptions.allowUnusedLabels !== true)
+    c.addErrorOrSuggestion(
+      c.compilerOptions.allowUnusedLabels === false,
+      createDiagnosticForNode(label, Diagnostics.Unused_label, []),
+    );
+  checkSourceElement(c, statement);
+}
+
+export function checkThrowStatement(c: Checker, node: Node): void {
+  const expr = getExpression(node);
+  if (expr !== undefined) checkExpression(c, expr);
+}
+
+export function checkTryStatement(c: Checker, node: Node): void {
+  const s = node as TryStatement;
+  checkBlock(c, s.tryBlock);
+  const catchClause: CatchClause | undefined = s.catchClause;
+  if (catchClause !== undefined) {
+    if (catchClause.variableDeclaration !== undefined) checkVariableLikeDeclaration(c, catchClause.variableDeclaration);
+    checkBlock(c, catchClause.block);
+  }
+  if (s.finallyBlock !== undefined) checkBlock(c, s.finallyBlock);
+}

package/src/compiler/checker-super.ts

@@ -0,0 +1,261 @@
+// `super` expressions and `this` before `super(...)` in derived class constructors.
+import { ScriptTarget } from './options.js';
+import { markSuperPropertyInStaticInitializer } from './checker-generated-code.js';
+import { type Node, getExpression, getFlowNode, getInitializer, getModifiers } from './ast.js';
+import { isClassElement, isClassLike, isStatic } from './binder-utilities.js';
+import { type DiagnosticMessage, Diagnostics } from './diagnostics.js';
+import { type FlowNode, FlowFlags, type FlowReduceLabel } from './flow.js';
+import { getBranchLabelAntecedents } from './checker-narrowing.js';
+import { SyntaxKind } from './syntax-kind.js';
+import type { Checker } from './checker.js';
+import { type InterfaceType, type Type, ObjectFlags, TypeFlags } from './checker-types.js';
+import {
+  getBaseConstructorTypeOfClass,
+  getBaseTypes,
+  getDeclaredTypeOfSymbol,
+  getExtendsHeritageClauseElement,
+} from './checker-declared-types.js';
+import { getTypeWithThisArgument } from './checker-members.js';
+import { getSymbolOfDeclaration } from './checker-symbols.js';
+
+/** The type of `super` in `super(...)`, `super.x` or `super[x]`, reporting where it can't be used. */
+export function checkSuperExpression(c: Checker, node: Node): Type {
+  const parent = node.parent!;
+  const isCallExpression = parent.kind === SyntaxKind.CallExpression && getExpression(parent) === node;
+  const immediateContainer = getSuperContainer(node, true);
+  let container = immediateContainer;
+  // `super` property accesses in arrow functions belong to the enclosing container.
+  if (!isCallExpression)
+    while (container !== undefined && container.kind === SyntaxKind.ArrowFunction)
+      container = getSuperContainer(container, true);
+  if (container === undefined || !isLegalUsageOfSuperExpression(container, isCallExpression)) {
+    if (isInComputedPropertyNameBefore(node, container))
+      c.error(node, Diagnostics.X_super_cannot_be_referenced_in_a_computed_property_name);
+    else if (isCallExpression)
+      c.error(
+        node,
+        Diagnostics.Super_calls_are_not_permitted_outside_constructors_or_in_nested_functions_inside_constructors,
+      );
+    else if (
+      container === undefined ||
+      container.parent === undefined ||
+      !(isClassLike(container.parent) || container.parent.kind === SyntaxKind.ObjectLiteralExpression)
+    )
+      c.error(
+        node,
+        Diagnostics.X_super_can_only_be_referenced_in_members_of_derived_classes_or_object_literal_expressions,
+      );
+    else
+      c.error(
+        node,
+        Diagnostics.X_super_property_access_is_permitted_only_in_a_constructor_member_function_or_member_accessor_of_a_derived_class,
+      );
+    return c.errorType;
+  }
+  if (!isCallExpression && immediateContainer!.kind === SyntaxKind.Constructor)
+    checkThisBeforeSuper(
+      c,
+      node,
+      container,
+      Diagnostics.X_super_must_be_called_before_accessing_a_property_of_super_in_the_constructor_of_a_derived_class,
+    );
+  // `super` in an object literal is `any`.
+  if (container.parent!.kind === SyntaxKind.ObjectLiteralExpression) return c.anyType;
+  const classLikeDeclaration = container.parent!;
+  if (getExtendsHeritageClauseElement(classLikeDeclaration) === undefined) {
+    c.error(node, Diagnostics.X_super_can_only_be_referenced_in_a_derived_class);
+    return c.errorType;
+  }
+  if (classDeclarationExtendsNull(c, classLikeDeclaration)) return isCallExpression ? c.errorType : c.nullWideningType;
+  const symbol = getSymbolOfDeclaration(c, classLikeDeclaration);
+  if (symbol === undefined) return c.errorType;
+  const classType = getDeclaredTypeOfSymbol(c, symbol);
+  const baseTypes = getBaseTypes(c, classType);
+  if (baseTypes.length === 0) return c.errorType;
+  if (container.kind === SyntaxKind.Constructor && isInConstructorArgumentInitializer(node, container)) {
+    c.error(node, Diagnostics.X_super_cannot_be_referenced_in_constructor_arguments);
+    return c.errorType;
+  }
+  if (isStatic(container) || isCallExpression) {
+    if (
+      !isCallExpression &&
+      c.languageVersion <= ScriptTarget.ES2021 &&
+      (container.kind === SyntaxKind.PropertyDeclaration || container.kind === SyntaxKind.ClassStaticBlockDeclaration)
+    )
+      markSuperPropertyInStaticInitializer(c, node);
+    return getBaseConstructorTypeOfClass(c, classType as InterfaceType);
+  }
+  return getTypeWithThisArgument(c, baseTypes[0]!, (classType as InterfaceType).thisType, false);
+}
+
+function isLegalUsageOfSuperExpression(container: Node, isCallExpression: boolean): boolean {
+  // Super calls are only permitted in constructors of derived classes.
+  if (isCallExpression) return container.kind === SyntaxKind.Constructor;
+  // Super property accesses are permitted in members directly within a class or object literal.
+  const parent = container.parent;
+  if (parent === undefined || !(isClassLike(parent) || parent.kind === SyntaxKind.ObjectLiteralExpression))
+    return false;
+  switch (container.kind) {
+    case SyntaxKind.MethodDeclaration:
+    case SyntaxKind.MethodSignature:
+    case SyntaxKind.GetAccessor:
+    case SyntaxKind.SetAccessor:
+    case SyntaxKind.PropertyDeclaration:
+      return true;
+    case SyntaxKind.ClassStaticBlockDeclaration:
+      return isStatic(container);
+    case SyntaxKind.PropertySignature:
+    case SyntaxKind.Constructor:
+      return !isStatic(container);
+  }
+  return false;
+}
+
+/** Whether `node` is in a computed property name below `container`. */
+function isInComputedPropertyNameBefore(node: Node, container: Node | undefined): boolean {
+  for (let current = node.parent; current !== undefined && current !== container; current = current.parent)
+    if (current.kind === SyntaxKind.ComputedPropertyName) return true;
+  return false;
+}
+
+function isInConstructorArgumentInitializer(node: Node, constructorDeclaration: Node): boolean {
+  for (let current: Node | undefined = node; current !== undefined; current = current.parent) {
+    if (isFunctionLikeDeclarationKind(current.kind)) return false;
+    if (current.kind === SyntaxKind.Parameter && current.parent === constructorDeclaration) return true;
+  }
+  return false;
+}
+
+function isFunctionLikeDeclarationKind(kind: SyntaxKind): boolean {
+  switch (kind) {
+    case SyntaxKind.FunctionDeclaration:
+    case SyntaxKind.MethodDeclaration:
+    case SyntaxKind.Constructor:
+    case SyntaxKind.GetAccessor:
+    case SyntaxKind.SetAccessor:
+    case SyntaxKind.FunctionExpression:
+    case SyntaxKind.ArrowFunction:
+      return true;
+  }
+  return false;
+}
+
+/** The member or function `super` at `node` belongs to. */
+export function getSuperContainer(node: Node, stopOnFunctions: boolean): Node | undefined {
+  for (let current = node.parent; current !== undefined; current = current.parent) {
+    switch (current.kind) {
+      case SyntaxKind.ComputedPropertyName:
+        current = current.parent!;
+        break;
+      case SyntaxKind.FunctionDeclaration:
+      case SyntaxKind.FunctionExpression:
+      case SyntaxKind.ArrowFunction:
+        if (stopOnFunctions) return current;
+        break;
+      case SyntaxKind.PropertyDeclaration:
+      case SyntaxKind.PropertySignature:
+      case SyntaxKind.MethodDeclaration:
+      case SyntaxKind.MethodSignature:
+      case SyntaxKind.Constructor:
+      case SyntaxKind.GetAccessor:
+      case SyntaxKind.SetAccessor:
+      case SyntaxKind.ClassStaticBlockDeclaration:
+        return current;
+      case SyntaxKind.Decorator: {
+        // Decorators are applied outside the body of their class or method.
+        const decorated = current.parent!;
+        if (decorated.kind === SyntaxKind.Parameter && isClassElement(decorated.parent!)) current = decorated.parent!;
+        else if (isClassElement(decorated)) current = decorated;
+        break;
+      }
+    }
+  }
+  return undefined;
+}
+
+/** Reports `node` in a derived class constructor when it may run before `super(...)`. */
+export function checkThisBeforeSuper(c: Checker, node: Node, container: Node, message: DiagnosticMessage): void {
+  const containingClassDeclaration = container.parent!;
+  // Classes without `extends`, or extending `null`, don't call `super`.
+  if (getExtendsHeritageClauseElement(containingClassDeclaration) === undefined) return;
+  if (classDeclarationExtendsNull(c, containingClassDeclaration)) return;
+  const flow = getFlowNode(node);
+  if (flow !== undefined && !isPostSuperFlowNode(c, flow, false)) c.error(node, message);
+}
+
+export function classDeclarationExtendsNull(c: Checker, classDeclaration: Node): boolean {
+  const symbol = getSymbolOfDeclaration(c, classDeclaration);
+  if (symbol === undefined) return false;
+  const classType = getDeclaredTypeOfSymbol(c, symbol);
+  if ((classType.objectFlags & ObjectFlags.ClassOrInterface) === 0 || (classType.flags & TypeFlags.Object) === 0)
+    return false;
+  return getBaseConstructorTypeOfClass(c, classType as InterfaceType) === c.nullWideningType;
+}
+
+/** Whether every path to `start` passes a `super(...)` call. */
+function isPostSuperFlowNode(c: Checker, start: FlowNode, noCacheCheckIn: boolean): boolean {
+  let flow = start;
+  let noCacheCheck = noCacheCheckIn;
+  for (;;) {
+    const flags = flow.flags;
+    if ((flags & FlowFlags.Shared) !== 0) {
+      if (!noCacheCheck) {
+        const cached = c.flowNodePostSuper.get(flow);
+        if (cached !== undefined) return cached;
+        const postSuper = isPostSuperFlowNode(c, flow, true);
+        c.flowNodePostSuper.set(flow, postSuper);
+        return postSuper;
+      }
+      noCacheCheck = false;
+    }
+    if ((flags & (FlowFlags.Assignment | FlowFlags.Condition | FlowFlags.ArrayMutation | FlowFlags.SwitchClause)) !== 0)
+      flow = flow.antecedent!;
+    else if ((flags & FlowFlags.Call) !== 0) {
+      if (getExpression(flow.node!)!.kind === SyntaxKind.SuperKeyword) return true;
+      flow = flow.antecedent!;
+    } else if ((flags & FlowFlags.BranchLabel) !== 0) {
+      for (const antecedent of getBranchLabelAntecedents(c, flow))
+        if (!isPostSuperFlowNode(c, antecedent, false)) return false;
+      return true;
+    } else if ((flags & FlowFlags.LoopLabel) !== 0) {
+      // A loop is post-super when the path into its top is.
+      flow = flow.antecedents![0]!;
+    } else if ((flags & FlowFlags.ReduceLabel) !== 0) {
+      c.flowReduceLabels.push(flow as FlowReduceLabel);
+      const result = isPostSuperFlowNode(c, flow.antecedent!, false);
+      c.flowReduceLabels.pop();
+      return result;
+    }
+    // Unreachable nodes count as post-super to silence errors.
+    else return (flags & FlowFlags.Unreachable) !== 0;
+  }
+}
+
+/** Reports `this` in a static property initializer of a class with legacy decorators. */
+export function checkThisInStaticClassFieldInitializerInDecoratedClass(
+  c: Checker,
+  thisExpression: Node,
+  container: Node,
+): void {
+  if (container.kind !== SyntaxKind.PropertyDeclaration || !isStatic(container) || !c.legacyDecorators) return;
+  const initializer = getInitializer(container);
+  if (
+    initializer !== undefined &&
+    initializer.pos <= thisExpression.pos &&
+    thisExpression.pos <= initializer.end &&
+    hasDecoratorModifier(container.parent!)
+  )
+    c.error(thisExpression, Diagnostics.Cannot_use_this_in_a_static_property_initializer_of_a_decorated_class);
+}
+
+function hasDecoratorModifier(node: Node): boolean {
+  const modifiers = getModifiersOf(node);
+  if (modifiers === undefined) return false;
+  for (const modifier of modifiers) if (modifier.kind === SyntaxKind.Decorator) return true;
+  return false;
+}
+
+function getModifiersOf(node: Node): Node[] | undefined {
+  const list = getModifiers(node);
+  return list !== undefined ? list.nodes : undefined;
+}