@mpeggroup/mpeg-sdl-parser 4.0.0

package/src/prettier/print-abstract-node.ts

@@ -0,0 +1,224 @@
+import { type AstPath, type Doc, type ParserOptions } from "prettier";
+import type { AbstractArrayDimension } from "../ast/node/abstract-array-dimension.ts";
+import type { AbstractClassId } from "../ast/node/abstract-class-id.ts";
+import type { AbstractExpression } from "../ast/node/abstract-expression.ts";
+import type { AbstractNode } from "../ast/node/abstract-node.ts";
+import type { AbstractStatement } from "../ast/node/abstract-statement.ts";
+import type { AlignedModifier } from "../ast/node/aligned-modifier.ts";
+import type { ArrayElementAccess } from "../ast/node/array-element-access.ts";
+import type { BitModifier } from "../ast/node/bit-modifier.ts";
+import type { ClassMemberAccess } from "../ast/node/class-member-access.ts";
+import type { ElementaryType } from "../ast/node/elementary-type.ts";
+import type { ExpandableModifier } from "../ast/node/expandable-modifier.ts";
+import type { ExtendsModifier } from "../ast/node/extends-modifier.ts";
+import type { LengthAttribute } from "../ast/node/length-attribute.ts";
+import type { MapEntry } from "../ast/node/map-entry.ts";
+import type { NumberLiteral } from "../ast/node/number-literal.ts";
+import type { Parameter } from "../ast/node/parameter.ts";
+import type { ParameterList } from "../ast/node/parameter-list.ts";
+import type { ParameterValueList } from "../ast/node/parameter-value-list.ts";
+import type { Specification } from "../ast/node/specification.ts";
+import type { CaseClause } from "../ast/node/case-clause.ts";
+import type { DefaultClause } from "../ast/node/default-clause.ts";
+import type { Identifier } from "../ast/node/identifier.ts";
+import type { StringLiteral } from "../ast/node/string-literal.ts";
+import type { AggregateOutputValue } from "../ast/node/aggregate-output-value.ts";
+import type { ElementaryTypeOutputValue } from "../ast/node/elementary-type-output-value.ts";
+import type { Token } from "../ast/node/token.ts";
+import type { UnexpectedError } from "../ast/node/unexpected-error.ts";
+import type { RequiredNode } from "../ast/util/types.ts";
+import { NodeKind } from "../ast/node/enum/node-kind.ts";
+import { printAbstractExpression } from "./print-abstract-expression.ts";
+import { printMapEntry } from "./print-map-entry.ts";
+import { printSpecification } from "./print-specification.ts";
+import { printElementaryType } from "./print-elementary-type.ts";
+import { printStringLiteral } from "./print-string-literal.ts";
+import { printAbstractStatement } from "./print-abstract-statement.ts";
+import {
+  addTrailingTriviaDoc,
+  endsWithHardline,
+  getLeadingTriviaDoc,
+  getTrailingTriviaDoc,
+  removeLeadingBlanklines,
+  removeTrailingHardline,
+} from "./util/print-utils.ts";
+import { printUnexpectedError } from "./print-unexpected-error.ts";
+import { printAlignedModifier } from "./print-aligned-modifier.ts";
+import { printIdentifier } from "./print-identifier.ts";
+import { printLengthAttribute } from "./print-length-attribute.ts";
+import { printNumberLiteral } from "./print-number-literal.ts";
+import { printBitModifier } from "./print-bit-modifier.ts";
+import { printAbstractClassId } from "./print-abstract-class-id.ts";
+import { printExpandableModifier } from "./print-expandable-modifier.ts";
+import { printExtendsModifier } from "./print-extends-modifier.ts";
+import { printParameter } from "./print-parameter.ts";
+import { printParameterList } from "./print-parameter-list.ts";
+import { printParameterValueList } from "./print-parameter-value-list.ts";
+import { printArrayElementAccess } from "./print-array-element-access.ts";
+import { printClassMemberAccess } from "./print-class-member-access.ts";
+import { printAggregateOutputValue } from "./print-aggregate-output-value.ts";
+import { printElementaryTypeOutputValue } from "./print-elementary-type-output-value.ts";
+import { printAbstractArrayDimension } from "./print-abstract-array-dimension.ts";
+import { printCaseClause } from "./print-case-clause.ts";
+import { printDefaultClause } from "./print-default-clause.ts";
+import { printToken } from "./print-token.ts";
+import { StatementKind } from "../ast/node/enum/statement-kind.ts";
+import { InternalScannerError } from "../scanner-error.ts";
+
+export function printAbstractNode(
+  path: AstPath<RequiredNode<AbstractNode>>,
+  _options: ParserOptions<AbstractNode>,
+  print: (_path: AstPath<RequiredNode<AbstractNode>>) => Doc,
+): Doc {
+  const node = path.node;
+  const nodeKind = node.nodeKind;
+
+  let doc: Doc = [];
+
+  let leadingTriviaDoc = getLeadingTriviaDoc(node);
+
+  if (leadingTriviaDoc) {
+    // prevent extra lines at beginning of compount statement
+    if (
+      (nodeKind === NodeKind.STATEMENT) &&
+      ((node as AbstractStatement).statementKind === StatementKind.COMPOUND)
+    ) {
+      leadingTriviaDoc = removeLeadingBlanklines(leadingTriviaDoc);
+    }
+    doc.push(leadingTriviaDoc);
+  }
+
+  switch (nodeKind) {
+    case NodeKind.AGGREGATE_OUTPUT_VALUE:
+      doc.push(printAggregateOutputValue(
+        path as AstPath<AggregateOutputValue>,
+        print,
+      ));
+      break;
+    case NodeKind.ALIGNED_MODIFIER:
+      doc.push(printAlignedModifier(path as AstPath<AlignedModifier>, print));
+      break;
+    case NodeKind.ARRAY_DIMENSION:
+      doc.push(printAbstractArrayDimension(
+        path as AstPath<AbstractArrayDimension>,
+        print,
+      ));
+      break;
+    case NodeKind.ARRAY_ELEMENT_ACCESS:
+      doc.push(printArrayElementAccess(
+        path as AstPath<ArrayElementAccess>,
+        print,
+      ));
+      break;
+    case NodeKind.BIT_MODIFIER:
+      doc.push(printBitModifier(path as AstPath<BitModifier>, print));
+      break;
+    case NodeKind.CASE_CLAUSE:
+      doc.push(printCaseClause(path as AstPath<CaseClause>, print));
+      break;
+    case NodeKind.CLASS_ID:
+      doc.push(printAbstractClassId(path as AstPath<AbstractClassId>, print));
+      break;
+    case NodeKind.CLASS_MEMBER_ACCESS:
+      doc.push(
+        printClassMemberAccess(path as AstPath<ClassMemberAccess>, print),
+      );
+      break;
+    case NodeKind.DEFAULT_CLAUSE:
+      doc.push(printDefaultClause(
+        path as AstPath<DefaultClause>,
+        print,
+      ));
+      break;
+    case NodeKind.ELEMENTARY_TYPE:
+      doc.push(printElementaryType(path as AstPath<ElementaryType>, print));
+      break;
+    case NodeKind.ELEMENTARY_TYPE_OUTPUT_VALUE:
+      doc.push(printElementaryTypeOutputValue(
+        path as AstPath<ElementaryTypeOutputValue>,
+        print,
+      ));
+      break;
+    case NodeKind.EXPRESSION:
+      doc.push(printAbstractExpression(
+        path as AstPath<AbstractExpression>,
+        print,
+      ));
+      break;
+    case NodeKind.EXPANDABLE_MODIFIER:
+      doc.push(printExpandableModifier(
+        path as AstPath<ExpandableModifier>,
+        print,
+      ));
+      break;
+    case NodeKind.EXTENDS_MODIFIER:
+      doc.push(printExtendsModifier(path as AstPath<ExtendsModifier>, print));
+      break;
+    case NodeKind.IDENTIFIER:
+      doc.push(printIdentifier(path as AstPath<Identifier>, print));
+      break;
+    case NodeKind.LENGTH_ATTRIBUTE:
+      doc.push(printLengthAttribute(path as AstPath<LengthAttribute>, print));
+      break;
+    case NodeKind.MAP_ENTRY:
+      doc.push(printMapEntry(path as AstPath<MapEntry>, print));
+      break;
+    case NodeKind.NUMBER_LITERAL:
+      doc.push(printNumberLiteral(path as AstPath<NumberLiteral>, print));
+      break;
+    case NodeKind.PARAMETER:
+      doc.push(printParameter(path as AstPath<Parameter>, print));
+      break;
+    case NodeKind.PARAMETER_LIST:
+      doc.push(printParameterList(path as AstPath<ParameterList>, print));
+      break;
+    case NodeKind.PARAMETER_VALUE_LIST:
+      doc.push(printParameterValueList(
+        path as AstPath<ParameterValueList>,
+        print,
+      ));
+      break;
+    case NodeKind.SPECIFICATION:
+      doc.push(printSpecification(path as AstPath<Specification>, print));
+      break;
+    case NodeKind.STATEMENT:
+      doc.push(
+        printAbstractStatement(path as AstPath<AbstractStatement>, print),
+      );
+      break;
+    case NodeKind.STRING_LITERAL:
+      doc.push(printStringLiteral(path as AstPath<StringLiteral>, print));
+      break;
+    case NodeKind.TOKEN:
+      doc.push(printToken(path as AstPath<Token>));
+      break;
+    case NodeKind.UNEXPECTED_ERROR:
+      doc.push(printUnexpectedError(path as AstPath<UnexpectedError>, print));
+      break;
+    default: {
+      const exhaustiveCheck: never = nodeKind;
+      throw new InternalScannerError(
+        "Unreachable code reached, nodeKind == " + exhaustiveCheck,
+      );
+    }
+  }
+
+  const trailingTriviaDoc = getTrailingTriviaDoc(node);
+  if (trailingTriviaDoc) {
+    // prevent extra lines at end of specification
+    if (
+      (nodeKind === NodeKind.SPECIFICATION) && endsWithHardline(doc) &&
+      endsWithHardline(trailingTriviaDoc)
+    ) {
+      doc = removeTrailingHardline(doc);
+    }
+    doc = addTrailingTriviaDoc(doc, trailingTriviaDoc);
+  }
+
+  // trim unneeded arrays
+  while (Array.isArray(doc) && (doc.length === 1)) {
+    doc = doc[0];
+  }
+
+  return doc;
+}

package/src/prettier/print-abstract-statement.ts

@@ -0,0 +1,124 @@
+import { AstPath, type Doc, doc } from "prettier";
+import { addIndentedStatements } from "./util/print-utils.ts";
+import { printArrayDefinition } from "./print-array-definition.ts";
+import { printDoStatement } from "./print-do-statement.ts";
+import { printForStatement } from "./print-for-statement.ts";
+import { printWhileStatement } from "./print-while-statement.ts";
+import { printIfStatement } from "./print-if-statement.ts";
+import { printSwitchStatement } from "./print-switch-statement.ts";
+import type { AbstractNode } from "../ast/node/abstract-node.ts";
+import type { AbstractStatement } from "../ast/node/abstract-statement.ts";
+import type { ArrayDefinition } from "../ast/node/array-definition.ts";
+import type { ClassDefinition } from "../ast/node/class-definition.ts";
+import type { CompoundStatement } from "../ast/node/compound-statement.ts";
+import type { ComputedArrayDefinition } from "../ast/node/computed-array-definition.ts";
+import type { ComputedElementaryTypeDefinition } from "../ast/node/computed-elementary-type-definition.ts";
+import type { ElementaryTypeDefinition } from "../ast/node/elementary-type-definition.ts";
+import { StatementKind } from "../ast/node/enum/statement-kind.ts";
+import type { MapDeclaration } from "../ast/node/map-declaration.ts";
+import type { MapDefinition } from "../ast/node/map-definition.ts";
+import type { StringDefinition } from "../ast/node/string-definition.ts";
+import type { ExpressionStatement } from "../ast/node/expression-statement.ts";
+import type { SwitchStatement } from "../ast/node/switch-statement.ts";
+import type { IfStatement } from "../ast/node/if-statement.ts";
+import type { WhileStatement } from "../ast/node/while-statement.ts";
+import type { ForStatement } from "../ast/node/for-statement.ts";
+import type { DoStatement } from "../ast/node/do-statement.ts";
+import type { ClassDeclaration } from "../ast/node/class-declaration.ts";
+import { printClassDeclaration } from "./print-class-declaration.ts";
+import { printClassDefinition } from "./print-class-definition.ts";
+import { printComputedArrayDefinition } from "./print-computed-array-definition.ts";
+import { printMapDeclaration } from "./print-map-declaration.ts";
+import { printStringDefinition } from "./print-string-definition.ts";
+import { printMapDefinition } from "./print-map-definition.ts";
+import { printComputedElementaryTypeDefinition } from "./print-computed-elementary-type-definition.ts";
+import { printElementaryTypeDefinition } from "./print-elementary-type-definition.ts";
+import { InternalScannerError } from "../scanner-error.ts";
+
+const { fill } = doc.builders;
+
+function printCompoundStatement(
+  path: AstPath<CompoundStatement>,
+  print: (path: AstPath<AbstractNode>) => Doc,
+): Doc {
+  let doc: Doc = [];
+
+  const statementsDoc = path.map(print, "statements");
+  doc = addIndentedStatements(
+    doc,
+    statementsDoc,
+    path.call(print, "openBracePunctuator"),
+    path.call(print, "closeBracePunctuator"),
+  );
+  return doc;
+}
+
+function printExpressionStatement(
+  path: AstPath<ExpressionStatement>,
+  print: (_path: AstPath<AbstractNode>) => Doc,
+): Doc {
+  return fill([
+    path.call(print, "expression"),
+    path.call(print, "semicolonPunctuator"),
+  ]);
+}
+
+export function printAbstractStatement(
+  path: AstPath<AbstractStatement>,
+  print: (_path: AstPath<AbstractNode>) => Doc,
+): Doc {
+  const abstractStatement = path.node;
+  const statementKind = abstractStatement.statementKind;
+  switch (statementKind) {
+    case StatementKind.ARRAY_DEFINITION:
+      return printArrayDefinition(path as AstPath<ArrayDefinition>, print);
+    case StatementKind.COMPUTED_ARRAY_DEFINITION:
+      return printComputedArrayDefinition(
+        path as AstPath<ComputedArrayDefinition>,
+        print,
+      );
+    case StatementKind.COMPUTED_ELEMENTARY_TYPE_DEFINITION:
+      return printComputedElementaryTypeDefinition(
+        path as AstPath<ComputedElementaryTypeDefinition>,
+        print,
+      );
+    case StatementKind.CLASS_DECLARATION:
+      return printClassDeclaration(path as AstPath<ClassDeclaration>, print);
+    case StatementKind.CLASS_DEFINITION:
+      return printClassDefinition(path as AstPath<ClassDefinition>, print);
+    case StatementKind.COMPOUND:
+      return printCompoundStatement(path as AstPath<CompoundStatement>, print);
+    case StatementKind.DO:
+      return printDoStatement(path as AstPath<DoStatement>, print);
+    case StatementKind.ELEMENTARY_TYPE_DEFINITION:
+      return printElementaryTypeDefinition(
+        path as AstPath<ElementaryTypeDefinition>,
+        print,
+      );
+    case StatementKind.EXPRESSION:
+      return printExpressionStatement(
+        path as AstPath<ExpressionStatement>,
+        print,
+      );
+    case StatementKind.FOR:
+      return printForStatement(path as AstPath<ForStatement>, print);
+    case StatementKind.IF:
+      return printIfStatement(path as AstPath<IfStatement>, print);
+    case StatementKind.MAP_DECLARATION:
+      return printMapDeclaration(path as AstPath<MapDeclaration>, print);
+    case StatementKind.MAP_DEFINITION:
+      return printMapDefinition(path as AstPath<MapDefinition>, print);
+    case StatementKind.STRING_DEFINITION:
+      return printStringDefinition(path as AstPath<StringDefinition>, print);
+    case StatementKind.SWITCH:
+      return printSwitchStatement(path as AstPath<SwitchStatement>, print);
+    case StatementKind.WHILE:
+      return printWhileStatement(path as AstPath<WhileStatement>, print);
+    default: {
+      const exhaustiveCheck: never = statementKind;
+      throw new InternalScannerError(
+        "Unreachable code reached, statementKind == " + exhaustiveCheck,
+      );
+    }
+  }
+}

package/src/prettier/print-aggregate-output-value.ts

@@ -0,0 +1,35 @@
+import type { AstPath, Doc, doc } from "prettier";
+import type { AbstractNode } from "../ast/node/abstract-node.ts";
+import type { AggregateOutputValue } from "../ast/node/aggregate-output-value.ts";
+import {
+  addNonBreakingWhitespace,
+  interleaveCommaSeparatorDocs,
+} from "./util/print-utils.ts";
+
+export function printAggregateOutputValue(
+  path: AstPath<AggregateOutputValue>,
+  print: (path: AstPath<AbstractNode>) => Doc,
+): doc.builders.Doc {
+  const doc: Doc = [];
+
+  doc.push(
+    path.call(print, "openBracePunctuator"),
+  );
+
+  addNonBreakingWhitespace(doc);
+
+  const outputValuesDoc = path.map(print, "outputValues");
+
+  doc.push(
+    interleaveCommaSeparatorDocs(
+      outputValuesDoc,
+      path.map(print, "commaPunctuators"),
+    ),
+  );
+
+  addNonBreakingWhitespace(doc);
+
+  doc.push(path.call(print, "closeBracePunctuator"));
+
+  return doc;
+}

package/src/prettier/print-aligned-modifier.ts

@@ -0,0 +1,50 @@
+import type { AstPath, Doc } from "prettier";
+import type { AlignedModifier } from "../ast/node/aligned-modifier.ts";
+import type { AbstractNode } from "../ast/node/abstract-node.ts";
+
+export function printAlignedModifier(
+  path: AstPath<AlignedModifier>,
+  print: (path: AstPath<AbstractNode>) => Doc,
+): Doc {
+  const alignedModifier = path.node;
+
+  const doc: Doc = [];
+
+  const d = path.call(print, "alignedKeyword");
+  doc.push(d);
+
+  if (alignedModifier.openParenthesisPunctuator) {
+    doc.push(
+      path.call(
+        print,
+        "openParenthesisPunctuator" as keyof AlignedModifier[
+          "openParenthesisPunctuator"
+        ],
+      ),
+    );
+  }
+
+  if (alignedModifier.bitCountModifierToken) {
+    doc.push(
+      path.call(
+        print,
+        "bitCountModifierToken" as keyof AlignedModifier[
+          "bitCountModifierToken"
+        ],
+      ),
+    );
+  }
+
+  if (alignedModifier.closeParenthesisPunctuator) {
+    doc.push(
+      path.call(
+        print,
+        "closeParenthesisPunctuator" as keyof AlignedModifier[
+          "closeParenthesisPunctuator"
+        ],
+      ),
+    );
+  }
+
+  return doc;
+}

package/src/prettier/print-array-definition.ts

@@ -0,0 +1,95 @@
+import { AstPath, type Doc, doc } from "prettier";
+import {
+  addBreakingWhitespace,
+  addNonBreakingWhitespace,
+} from "./util/print-utils.ts";
+import type { ArrayDefinition } from "../ast/node/array-definition.ts";
+import type { AbstractNode } from "../ast/node/abstract-node.ts";
+
+const { fill } = doc.builders;
+
+export function printArrayDefinition(
+  path: AstPath<ArrayDefinition>,
+  print: (path: AstPath<AbstractNode>) => Doc,
+): Doc {
+  const arrayDefinition = path.node;
+  let doc: Doc = [];
+
+  if (arrayDefinition.reservedKeyword) {
+    doc.push(
+      path.call(
+        print,
+        "reservedKeyword" as keyof ArrayDefinition["reservedKeyword"],
+      ),
+    );
+    addNonBreakingWhitespace(doc);
+  }
+
+  if (arrayDefinition.legacyKeyword) {
+    doc.push(
+      path.call(
+        print,
+        "legacyKeyword" as keyof ArrayDefinition["legacyKeyword"],
+      ),
+    );
+    addNonBreakingWhitespace(doc);
+  }
+
+  if (arrayDefinition.alignedModifier !== undefined) {
+    doc.push(
+      path.call(
+        print,
+        "alignedModifier" as keyof ArrayDefinition["alignedModifier"],
+      ),
+    );
+    addNonBreakingWhitespace(doc);
+  }
+
+  if (arrayDefinition.elementaryType !== undefined) {
+    const subDoc: Doc = [
+      path.call(
+        print,
+        "elementaryType" as keyof ArrayDefinition["elementaryType"],
+      ),
+      path.call(
+        print,
+        "lengthAttribute" as keyof ArrayDefinition["lengthAttribute"],
+      ),
+    ];
+    doc.push(subDoc);
+  } else {
+    doc.push(
+      path.call(
+        print,
+        "classIdentifier" as keyof ArrayDefinition["classIdentifier"],
+      ),
+    );
+  }
+
+  doc = addBreakingWhitespace(doc);
+
+  const identifierClause = [
+    path.call(print, "identifier"),
+  ];
+
+  if (arrayDefinition.implicitArrayDimension) {
+    identifierClause.push(
+      path.call(
+        print,
+        "implicitArrayDimension" as keyof ArrayDefinition[
+          "implicitArrayDimension"
+        ],
+      ),
+    );
+  }
+
+  if (arrayDefinition.dimensions) {
+    identifierClause.push(...path.map(print, "dimensions"));
+  }
+
+  identifierClause.push(path.call(print, "semicolonPunctuator"));
+
+  doc.push(identifierClause);
+
+  return fill(doc);
+}

package/src/prettier/print-array-element-access.ts

@@ -0,0 +1,14 @@
+import type { AstPath, Doc } from "prettier";
+import type { AbstractNode } from "../ast/node/abstract-node.ts";
+import type { ArrayElementAccess } from "../ast/node/array-element-access.ts";
+
+export function printArrayElementAccess(
+  path: AstPath<ArrayElementAccess>,
+  print: (path: AstPath<AbstractNode>) => Doc,
+): Doc {
+  return [
+    path.call(print, "openBracketPunctuator"),
+    path.call(print, "index"),
+    path.call(print, "closeBracketPunctuator"),
+  ];
+}

package/src/prettier/print-bit-modifier.ts

@@ -0,0 +1,48 @@
+import type { AstPath, Doc } from "prettier";
+import type { AbstractNode } from "../ast/node/abstract-node.ts";
+import type { BitModifier } from "../ast/node/bit-modifier.ts";
+import {
+  addBreakingWhitespace,
+  addNonBreakingWhitespace,
+} from "./util/print-utils.ts";
+
+export function printBitModifier(
+  path: AstPath<BitModifier>,
+  print: (path: AstPath<AbstractNode>) => Doc,
+): Doc {
+  const bitModifier = path.node;
+  let doc: Doc = [];
+
+  doc.push(path.call(print, "colonPunctuator"));
+  addNonBreakingWhitespace(doc);
+
+  const subDoc: Doc = [];
+
+  subDoc.push(path.call(print, "bitKeyword"));
+  subDoc.push(path.call(print, "openParenthesisPunctuator"));
+  subDoc.push(path.call(print, "length"));
+  subDoc.push(path.call(print, "closeParenthesisPunctuator"));
+  doc.push(subDoc);
+  addNonBreakingWhitespace(doc);
+
+  if (bitModifier.identifier !== undefined) {
+    doc.push(
+      path.call(
+        print,
+        "identifier" as keyof BitModifier["identifier"],
+      ),
+    );
+    addNonBreakingWhitespace(doc);
+    doc.push(
+      path.call(
+        print,
+        "assignmentOperator" as keyof BitModifier["assignmentOperator"],
+      ),
+    );
+    doc = addBreakingWhitespace(doc);
+  }
+
+  doc.push(path.call(print, "classId"));
+
+  return doc;
+}

package/src/prettier/print-case-clause.ts

@@ -0,0 +1,58 @@
+import type { AstPath, Doc } from "prettier";
+import type { AbstractNode } from "../ast/node/abstract-node.ts";
+import {
+  addIndentedStatements,
+  addNonBreakingWhitespace,
+} from "./util/print-utils.ts";
+import type { CaseClause } from "../ast/node/case-clause.ts";
+
+export function printCaseClause(
+  path: AstPath<CaseClause>,
+  print: (path: AstPath<AbstractNode>) => Doc,
+): Doc {
+  const caseClause = path.node;
+  let doc: Doc = [];
+
+  doc.push(path.call(print, "caseKeyword"));
+  addNonBreakingWhitespace(doc);
+
+  doc.push([
+    path.call(print, "value"),
+    path.call(print, "colonPunctuator"),
+  ]);
+
+  const statementsDocs: Doc[] = [];
+
+  if (caseClause.statements.length > 0) {
+    statementsDocs.push(path.map(print, "statements"));
+  }
+  if (caseClause.breakKeyword !== undefined) {
+    statementsDocs.push([[
+      path.call(print, "breakKeyword" as keyof CaseClause["breakKeyword"]),
+      path.call(
+        print,
+        "semicolonPunctuator" as keyof CaseClause["semicolonPunctuator"],
+      ),
+    ]]);
+  }
+
+  if (caseClause.openBracePunctuator !== undefined) {
+    doc.push(" ");
+    doc = addIndentedStatements(
+      doc,
+      statementsDocs,
+      path.call(
+        print,
+        "openBracePunctuator" as keyof CaseClause["openBracePunctuator"],
+      ),
+      path.call(
+        print,
+        "closeBracePunctuator" as keyof CaseClause["closeBracePunctuator"],
+      ),
+    );
+  } else {
+    doc = addIndentedStatements(doc, statementsDocs);
+  }
+
+  return doc;
+}