@mpeggroup/mpeg-sdl-parser 4.0.0

package/tests/lezer/test-cases/while_statement.txt

@@ -0,0 +1,45 @@
+# Simple
+
+class A {while (i<9) {i++;}}
+
+==>
+
+Specification(
+    ClassDeclaration(
+        class,
+        Whitespace
+        Identifier
+        Whitespace
+        OpenBrace
+        WhileStatement(
+            while
+            Whitespace
+            OpenParenthesis
+            BinaryExpression(
+                UnaryExpression(
+                    Identifier
+                )
+                RelationalLessThan
+                UnaryExpression(
+                    IntegerLiteral
+                )
+            )
+            CloseParenthesis
+            Whitespace
+            CompoundStatement(
+                OpenBrace
+                ExpressionStatement(
+                    UnaryExpression(
+                        UnaryExpression(
+                            Identifier
+                        )
+                        PostfixIncrement
+                    )
+                    Semicolon
+                )
+                CloseBrace
+            )
+        )
+        CloseBrace
+    )
+)

package/tests/parse-helper.test.ts

@@ -0,0 +1,361 @@
+import { describe, expect, test } from "bun:test";
+import { type Buffer } from "node:buffer";
+import path from "node:path";
+import { promises as fs } from "node:fs";
+import HistoryRecordingNodeHandler, {
+  expectedHistory,
+} from "./fixtures/history-recording-node-handler.ts";
+import { buildAst } from "../src/ast/build-ast.ts";
+import {
+  createLenientSdlParser,
+  createStrictSdlParser,
+} from "../src/lezer/create-sdl-parser.ts";
+import {
+  collateSyntaxErrors,
+  dispatchNodeHandler,
+  prettyPrint,
+} from "../src/parse-helper.ts";
+import { SdlStringInput } from "../src/lezer/sdl-string-input.ts";
+import type { Specification } from "../src/ast/node/specification.ts";
+
+const strictSdlParser = createStrictSdlParser();
+const lenientSdlParser = createLenientSdlParser();
+
+describe("Parse Helper Tests", () => {
+  test("Test collateSyntaxErrors - invalid sample specification", async () => {
+    const sdlString = await fs.readFile(
+      path.join(__dirname, "./sample-specifications/invalid.sdl"),
+    ).then((buffer: Buffer) => buffer.toString());
+
+    const sdlStringInput = new SdlStringInput(sdlString);
+    const parseTree = lenientSdlParser.parse(sdlStringInput);
+    const syntaxErrors = collateSyntaxErrors(parseTree, sdlStringInput);
+
+    expect(syntaxErrors).toHaveLength(5);
+    expect(syntaxErrors[0].errorLine).toEqual(
+      "  bit           transport_priority;",
+    );
+    expect(syntaxErrors[1].errorLine).toEqual("  unsigned int N = 184;");
+    expect(syntaxErrors[2].errorLine).toEqual(
+      "  if (adaptation_ field_control == 0b01 || adaptation_field_control == 0b11) {",
+    );
+    expect(syntaxErrors[0].location!.column).toEqual(17);
+    expect(syntaxErrors[1].location!.column).toEqual(16);
+    expect(syntaxErrors[2].location!.column).toEqual(19);
+  });
+
+  test("Test collateSyntaxErrors - invalid elementary type definition", () => {
+    const sdlStringInput = new SdlStringInput(
+      "class A{bit transport_priority;}",
+    );
+    const parseTree = lenientSdlParser.parse(sdlStringInput);
+    const syntaxErrors = collateSyntaxErrors(parseTree, sdlStringInput);
+
+    expect(syntaxErrors[0].message).toBe(
+      "SYNTAX ERROR: Expected: <LengthAttribute> => { row: 1, column: 13, position: 12 }",
+    );
+  });
+
+  test("Test collateSyntaxErrors - no class parameter values in parenthesis fails to parse", () => {
+    const sdlStringInput = new SdlStringInput("class A {ClassD d();}");
+    const parseTree = lenientSdlParser.parse(sdlStringInput);
+    const syntaxErrors = collateSyntaxErrors(parseTree, sdlStringInput);
+
+    expect(syntaxErrors[0].message).toBe(
+      "SYNTAX ERROR: Expected one of: - ( + <BinaryLiteral> <DecimalLiteral> <FloatingPointLiteral> <HexadecimalLiteral> <Identifier> <IntegerLiteral> <LengthofExpression> <MultipleCharacterLiteral> => { row: 1, column: 19, position: 18 }",
+    );
+  });
+
+  test("Test collateSyntaxErrors - unexpected token fails to parse", () => {
+    const sdlStringInput = new SdlStringInput("class A {ClassD computed d;}");
+    const parseTree = lenientSdlParser.parse(sdlStringInput);
+    const syntaxErrors = collateSyntaxErrors(parseTree, sdlStringInput);
+
+    expect(syntaxErrors[0].message).toBe(
+      "SYNTAX ERROR: Unexpected: computed => { row: 1, column: 17, position: 16 }",
+    );
+  });
+
+  test("Test collateSyntaxErrors - trailing comma in class parameter values fails to parse", () => {
+    const sdlStringInput = new SdlStringInput("class A {ClassD d(3,);}");
+    const parseTree = lenientSdlParser.parse(sdlStringInput);
+    const syntaxErrors = collateSyntaxErrors(parseTree, sdlStringInput);
+
+    expect(syntaxErrors[0].message).toBe(
+      "SYNTAX ERROR: Expected one of: <BinaryExpression> <UnaryExpression> => { row: 1, column: 21, position: 20 }",
+    );
+  });
+
+  test("Test collateSyntaxErrors - unterminated class parameter values ending in expression fails to parse", () => {
+    const sdlStringInput = new SdlStringInput("class A {ClassD d(3;}");
+    const parseTree = lenientSdlParser.parse(sdlStringInput);
+    const syntaxErrors = collateSyntaxErrors(parseTree, sdlStringInput);
+
+    expect(syntaxErrors[0].message).toBe(
+      "SYNTAX ERROR: Expected one of: - , != ) * / & && % + < << <= == > >= >> | || => { row: 1, column: 20, position: 19 }",
+    );
+  });
+
+  test("Test collateSyntaxErrors - unterminated class parameter values ending in comma fails to parse", () => {
+    const sdlStringInput = new SdlStringInput("class A {ClassD d(3,;}");
+    const parseTree = lenientSdlParser.parse(sdlStringInput);
+    const syntaxErrors = collateSyntaxErrors(parseTree, sdlStringInput);
+
+    expect(syntaxErrors[0].message).toBe(
+      "SYNTAX ERROR: Expected one of: <BinaryExpression> <UnaryExpression> => { row: 1, column: 21, position: 20 }",
+    );
+  });
+
+  test("Test collateSyntaxErrors - unterminated string literal types fails to parse", () => {
+    const sdlStringInput = new SdlStringInput(
+      'class A {utf8string d = u";}',
+    );
+    const parseTree = lenientSdlParser.parse(sdlStringInput);
+    const syntaxErrors = collateSyntaxErrors(parseTree, sdlStringInput);
+
+    expect(syntaxErrors[0].message).toBe(
+      'SYNTAX ERROR: Expected: " => { row: 1, column: 29, position: 28 }',
+    );
+  });
+
+  test("Test collateSyntaxErrors - missing utf string literal types fails to parse", () => {
+    const sdlStringInput = new SdlStringInput(
+      "class A {utf8string d = ;}",
+    );
+    const parseTree = lenientSdlParser.parse(sdlStringInput);
+    const syntaxErrors = collateSyntaxErrors(parseTree, sdlStringInput);
+
+    expect(syntaxErrors[0].message).toBe(
+      "SYNTAX ERROR: Expected: <UtfStringLiteral> => { row: 1, column: 25, position: 24 }",
+    );
+  });
+
+  test("Test collateSyntaxErrors - missing string literal types fails to parse", () => {
+    const sdlStringInput = new SdlStringInput(
+      "class A {base64string d = ;}",
+    );
+    const parseTree = lenientSdlParser.parse(sdlStringInput);
+    const syntaxErrors = collateSyntaxErrors(parseTree, sdlStringInput);
+
+    expect(syntaxErrors[0].message).toBe(
+      "SYNTAX ERROR: Expected: <Base64StringLiteral> => { row: 1, column: 27, position: 26 }",
+    );
+  });
+
+  test("Test collateSyntaxErrors - mix of concatenated string literal types fails to parse", () => {
+    const sdlStringInput = new SdlStringInput(
+      'class A {utf8string d = u"hello" "world";}',
+    );
+    const parseTree = lenientSdlParser.parse(sdlStringInput);
+    const syntaxErrors = collateSyntaxErrors(parseTree, sdlStringInput);
+
+    expect(syntaxErrors[0].message).toBe(
+      "SYNTAX ERROR: Expected: u => { row: 1, column: 34, position: 33 }",
+    );
+  });
+
+  test("Test collateSyntaxErrors - both legacy and reserved together fails to parse", () => {
+    const sdlStringInput = new SdlStringInput(
+      "class A {reserved legacy utfstring foo;}",
+    );
+    const parseTree = lenientSdlParser.parse(sdlStringInput);
+    const syntaxErrors = collateSyntaxErrors(parseTree, sdlStringInput);
+
+    expect(syntaxErrors[0].message).toBe(
+      "SYNTAX ERROR: Expected one of: base64string const utf16string utf8string utfstring <AlignedModifier> => { row: 1, column: 19, position: 18 }",
+    );
+  });
+
+  test("Test collateSyntaxErrors - unexpected prefix for string literal", () => {
+    const sdlStringInput = new SdlStringInput(
+      'class A {base64string foo = u"aGVsbG8K";}',
+    );
+    const parseTree = lenientSdlParser.parse(sdlStringInput);
+    const syntaxErrors = collateSyntaxErrors(parseTree, sdlStringInput);
+
+    expect(syntaxErrors[0].message).toBe(
+      "SYNTAX ERROR: Unexpected: u => { row: 1, column: 29, position: 28 }",
+    );
+  });
+
+  test("Test collateSyntaxErrors - invalid basic string literal type fails to parse", () => {
+    const sdlStringInput = new SdlStringInput(
+      'class A {utf8string foo = "hello";}',
+    );
+    const parseTree = lenientSdlParser.parse(sdlStringInput);
+    const syntaxErrors = collateSyntaxErrors(parseTree, sdlStringInput);
+
+    expect(syntaxErrors[0].message).toBe(
+      "SYNTAX ERROR: Expected: u => { row: 1, column: 27, position: 26 }",
+    );
+  });
+
+  test("Test collateSyntaxErrors - invalid prefix for string literal", () => {
+    const sdlStringInput = new SdlStringInput(
+      'class A {utf8string foo = u8"hello";}',
+    );
+    const parseTree = lenientSdlParser.parse(sdlStringInput);
+    const syntaxErrors = collateSyntaxErrors(parseTree, sdlStringInput);
+
+    expect(syntaxErrors[0].message).toBe(
+      "SYNTAX ERROR: Unexpected: 8 => { row: 1, column: 28, position: 27 }",
+    );
+  });
+
+  test("Test collateSyntaxErrors - illegal alignment bit count value fails to parse", () => {
+    const sdlStringInput = new SdlStringInput(
+      "class A {aligned(17) utf8string foo;}",
+    );
+    const parseTree = lenientSdlParser.parse(sdlStringInput);
+    const syntaxErrors = collateSyntaxErrors(parseTree, sdlStringInput);
+
+    expect(syntaxErrors[0].message).toBe(
+      "SYNTAX ERROR: Expected one of: 8 16 32 64 128 => { row: 1, column: 18, position: 17 }",
+    );
+  });
+
+  test("Test collateSyntaxErrors - unterminated alignment modifier fails to parse", () => {
+    const sdlStringInput = new SdlStringInput(
+      "class A {aligned(16 utf8string foo;}",
+    );
+    const parseTree = lenientSdlParser.parse(sdlStringInput);
+    const syntaxErrors = collateSyntaxErrors(parseTree, sdlStringInput);
+
+    expect(syntaxErrors[0].message).toBe(
+      "SYNTAX ERROR: Expected: ) => { row: 1, column: 21, position: 20 }",
+    );
+  });
+
+  test("Test collateSyntaxErrors - while loop fails to parse", () => {
+    const sdlStringInput = new SdlStringInput("class A {while (1)}");
+    const parseTree = lenientSdlParser.parse(sdlStringInput);
+    const syntaxErrors = collateSyntaxErrors(parseTree, sdlStringInput);
+
+    expect(syntaxErrors[0].message).toBe(
+      "SYNTAX ERROR: Expected one of: <ArrayDefinition> <ClassDefinition> <CompoundStatement> <ComputedArrayDefinition> <ComputedElementaryTypeDefinition> <DoStatement> <ElementaryTypeDefinition> <ExpressionStatement> <ForStatement> <IfStatement> <MapDefinition> <StringDefinition> <SwitchStatement> <WhileStatement> => { row: 1, column: 19, position: 18 }",
+    );
+  });
+
+  test("Test collateSyntaxErrors - empty specification produces no errors", () => {
+    const sdlStringInput = new SdlStringInput("");
+    const parseTree = lenientSdlParser.parse(sdlStringInput);
+    const syntaxErrors = collateSyntaxErrors(parseTree, sdlStringInput);
+
+    expect(syntaxErrors.length).toBe(0);
+  });
+
+  test("Test collateSyntaxErrors - single invalid token produces error", () => {
+    const sdlStringInput = new SdlStringInput("§");
+    const parseTree = lenientSdlParser.parse(sdlStringInput);
+    const syntaxErrors = collateSyntaxErrors(parseTree, sdlStringInput);
+
+    expect(syntaxErrors[0].message).toBe(
+      "SYNTAX ERROR: Unknown token: § => { row: 1, column: 1, position: 0 }",
+    );
+  });
+
+  test("Test prettyPrint", async () => {
+    const sdlString = await fs.readFile(
+      path.join(__dirname, "./sample-specifications/various-elements.sdl"),
+    ).then((buffer: Buffer) => buffer.toString());
+    let expectedSdlString = await fs.readFile(
+      path.join(
+        __dirname,
+        "./sample-specifications/prettified-various-elements.sdl",
+      ),
+    ).then((buffer: Buffer) => buffer.toString());
+    expectedSdlString = expectedSdlString.replace(/\r/g, "");
+
+    const sdlStringInput = new SdlStringInput(sdlString);
+    const parseTree = strictSdlParser.parse(sdlStringInput);
+    const specification = buildAst(parseTree, sdlStringInput);
+
+    const prettifiedSdlString = await prettyPrint(
+      specification as Specification,
+      sdlStringInput,
+    );
+    expect(
+      prettifiedSdlString,
+    ).toEqual(
+      expectedSdlString,
+    );
+  });
+
+  test("Test prettyPrint - narrower", async () => {
+    const sdlString = await fs.readFile(
+      path.join(__dirname, "./sample-specifications/various-elements.sdl"),
+    ).then((buffer: Buffer) => buffer.toString());
+    let expectedSdlString = await fs.readFile(
+      path.join(
+        __dirname,
+        "./sample-specifications/prettified-various-elements-narrow.sdl",
+      ),
+    ).then((buffer: Buffer) => buffer.toString());
+    expectedSdlString = expectedSdlString.replace(/\r/g, "");
+
+    const sdlStringInput = new SdlStringInput(sdlString);
+    const parseTree = strictSdlParser.parse(sdlStringInput);
+    const specification = buildAst(parseTree, sdlStringInput);
+
+    const narrowPrettifiedSdlString = await prettyPrint(
+      specification as Specification,
+      sdlStringInput,
+      40,
+    );
+    expect(
+      narrowPrettifiedSdlString,
+    ).toEqual(
+      expectedSdlString,
+    );
+  });
+
+  test("Test prettyPrint - with syntax errors", async () => {
+    const sdlString = await fs.readFile(
+      path.join(__dirname, "./sample-specifications/invalid.sdl"),
+    ).then((buffer: Buffer) => buffer.toString());
+    let expectedSdlString = await fs.readFile(
+      path.join(
+        __dirname,
+        "./sample-specifications/prettified-invalid.sdl",
+      ),
+    ).then((buffer: Buffer) => buffer.toString());
+    expectedSdlString = expectedSdlString.replace(/\r/g, "");
+
+    const sdlStringInput = new SdlStringInput(sdlString);
+    const parseTree = lenientSdlParser.parse(sdlStringInput);
+    const specification = buildAst(parseTree, sdlStringInput, true);
+
+    const invalidPrettifiedSdlString = await prettyPrint(
+      specification as Specification,
+      sdlStringInput,
+    );
+    expect(
+      invalidPrettifiedSdlString,
+    ).toEqual(
+      expectedSdlString,
+    );
+  });
+
+  test("Test dispatchNodeHandler", async () => {
+    const sdlString = await fs.readFile(
+      path.join(__dirname, "./sample-specifications/sample.sdl"),
+    ).then((buffer: Buffer) => buffer.toString());
+
+    const sdlStringInput = new SdlStringInput(sdlString);
+    const parseTree = strictSdlParser.parse(sdlStringInput);
+    const specification = buildAst(parseTree, sdlStringInput);
+
+    const historyRecordingNodeHandler = new HistoryRecordingNodeHandler();
+
+    dispatchNodeHandler(
+      specification as Specification,
+      historyRecordingNodeHandler,
+    );
+
+    expect(
+      historyRecordingNodeHandler.nodeHistory,
+    ).toEqual(
+      expectedHistory,
+    );
+  });
+});

package/tests/prettier/__snapshots__/prettier-plugin-sdl.test.ts.snap

@@ -0,0 +1,127 @@
+// Bun Snapshot v1, https://bun.sh/docs/test/snapshots
+
+exports[`Prettier Plugin SDL tests prettified output is as expected 1`] = `
+"// repeated packets in bitstream
+//
+// should be declared in a wrapping Bitstream class
+class transport_packet {
+  unsigned int(8) sync_byte = 0x47;
+  bit(1) transport_error_indicator;
+  bit(1) payload_unit_start_indicator;
+  bit(1) transport_priority;
+  unsigned int(13 // odd but valid comment position
+  ) PID;
+  bit(2)* transport_scrambling_control;
+  aligned(16) bit(2) adaptation_field_control = 0x0000.0000;
+
+  computed unsigned int N = 184;
+  computed float test = 1e1;
+  utf8string foo = u"bar" u"foo";
+  base64string foo2 = "BAR";
+  computed int dummy1 = 'ABCD' '01AB';
+  computed int dummy2 = lengthof(transport_scrambling_control) + N++;
+  if (adaptation_field_control == 0b10 || adaptation_field_control == 0b11) {
+    adaptation_field data; // previously declared class
+
+    // N is 184 minus the number of bytes in the adaptation_field
+    N = N - // and another
+      1 // and another odd comment
+      - data.adaptation_field_length;
+  }
+  if (adaptation_field_control == 0b01 || adaptation_field_control == 0b11) {
+    bit(8) data_byte[N];
+  }
+}
+
+map Offsets (int) {
+  0b00, { 1024 },
+  0b01, { 2048 }
+}
+
+expandable(20) class odd(int a, B b) extends odder(a) : bit(2) id = 2 {
+  reserved unsigned int(Offsets) offset;
+  computed int myArray[2];
+  computed int i = 1;
+  Strange s(1, 2);
+  while (i < 2) {
+    i++;
+  }
+  i = 2;
+  do {
+    i--;
+  } while (i > 0);
+  if (1) {
+    i++;
+  }
+  else if (1) {
+    i--;
+  }
+  else {
+    i++;
+  }
+  if (1)
+    if (2)
+      i--;
+    else
+      i++;
+  switch (i) {
+    case 0:
+    case 1:
+      // nothing
+      break;
+    case 2: { // nothing
+      break;
+    }
+    default:
+      i++;
+    // foo
+  }
+}
+
+class odd2(int a) {
+  computed int x = 0;
+  for (computed int j = 0; j < 2; j++) {
+    x++;
+  }
+  for (; j > 0; j--) {
+  }
+}
+
+class A {
+  MyClass a[1..3];
+  reserved MyClass b[3][[2]];
+} // end of file
+"
+`;
+
+exports[`Prettier Plugin SDL tests can prettify with syntax errors 1`] = `
+"// repeated packets in bitstream
+class transport_packet {
+  unsigned int(8) sync_byte = 0x47;
+  bit(1) transport_error_indicator;
+  bit(1) payload_unit_start_indicator;
+  bit
+  transport_priority;
+  unsigned int(13) PID;
+  bit(2) transport_scrambling_control;
+  bit(2) adaptation_field_control;
+
+  unsigned int
+  N = 184;
+
+  if (adaptation_field_control == 0b10 || adaptation_field_control == 0b11) {
+    adaptation_field data; // previously declared class
+
+    // N is 184 minus the number of bytes in the adaptation_field
+    N = N - 1 - data.adaptation_field_length;
+  }
+
+  if (adaptation_
+
+  field_control == 0b01 || adaptation_field_control == 0b11)
+  {
+    bit(8) data_byte[N];
+  }
+} // until EOF
+"
+`;

package/tests/prettier/prettier-plugin-sdl.test.ts

@@ -0,0 +1,58 @@
+import * as prettier from "prettier";
+import { promises as fs } from "node:fs";
+import { type Buffer } from "node:buffer";
+import path from "node:path";
+import { describe, expect, test } from "bun:test";
+import { prettierPluginSdl } from "../../src/prettier/prettier-plugin-sdl.ts";
+import { createStrictSdlParser } from "../../src/lezer/create-sdl-parser.ts";
+import { SdlStringInput } from "../../src/lezer/sdl-string-input.ts";
+
+const strictSdlParser = createStrictSdlParser();
+
+describe("Prettier Plugin SDL tests", () => {
+  test("prettified output is as expected", async () => {
+    const sampleSdlSpecification = await fs.readFile(
+      path.join(__dirname, "../sample-specifications/various-elements.sdl"),
+    ).then((buffer: Buffer) => buffer.toString());
+
+    const options: prettier.Options = {
+      parser: "sdl",
+      plugins: [prettierPluginSdl],
+    };
+
+    const prettified = await prettier.format(sampleSdlSpecification, options);
+
+    expect(prettified).toMatchSnapshot();
+  });
+
+  test("prettified output is valid", async () => {
+    const sampleSdlSpecification = await fs.readFile(
+      path.join(__dirname, "../sample-specifications/various-elements.sdl"),
+    ).then((buffer: Buffer) => buffer.toString());
+
+    const options: prettier.Options = {
+      parser: "sdl",
+      plugins: [prettierPluginSdl],
+    };
+
+    const prettified = await prettier.format(sampleSdlSpecification, options);
+    const sdlStringInput = new SdlStringInput(prettified);
+
+    strictSdlParser.parse(sdlStringInput);
+  });
+
+  test("can prettify with syntax errors", async () => {
+    const sampleSdlSpecification = await fs.readFile(
+      path.join(__dirname, "../sample-specifications/invalid.sdl"),
+    ).then((buffer: Buffer) => buffer.toString());
+
+    const options: prettier.Options = {
+      parser: "sdl",
+      plugins: [prettierPluginSdl],
+    };
+
+    const prettified = await prettier.format(sampleSdlSpecification, options);
+
+    expect(prettified).toMatchSnapshot();
+  });
+});

package/tests/prettier/print-array.test.ts

@@ -0,0 +1,29 @@
+import { describe, test } from "bun:test";
+import { testPrettierScenario } from "./test-prettier-scenario.ts";
+
+describe("Print Array tests", () => {
+  test("prettified array output is as expected", async () => {
+    await testPrettierScenario(
+      "class A{aligned(16) bit(2) adaptation_field_control[4][5];}",
+      "class A {\n" +
+        "  aligned(16) bit(2) adaptation_field_control[4][5];\n" +
+        "}\n",
+      "class A {\n" +
+        "  aligned(16) bit(2)\n" +
+        "    adaptation_field_control[4][5];\n" +
+        "}\n",
+    );
+  });
+
+  test("prettified array output with implicit array is as expected", async () => {
+    await testPrettierScenario(
+      "class A{B b[2..4];}",
+      "class A {\n" +
+        "  B b[2..4];\n" +
+        "}\n",
+      "class A {\n" +
+        "  B b[2..4];\n" +
+        "}\n",
+    );
+  });
+});

package/tests/prettier/print-class.test.ts

@@ -0,0 +1,15 @@
+import { describe, test } from "bun:test";
+import { testPrettierScenario } from "./test-prettier-scenario.ts";
+
+describe("Print Class tests", () => {
+  test("prettified class output is as expected", async () => {
+    await testPrettierScenario(
+      "expandable(20) class odd(int a,B b) extends odder(a):bit(2) id= 2{}",
+      "expandable(20) class odd(int a, B b) extends odder(a) : bit(2) id = 2 {\n" +
+        "}\n",
+      "expandable(20) class odd(int a, B b)\n" +
+        "  extends odder(a) : bit(2) id = 2 {\n" +
+        "}\n",
+    );
+  });
+});

package/tests/prettier/print-do.test.ts

@@ -0,0 +1,25 @@
+import { describe, test } from "bun:test";
+import { testPrettierScenario } from "./test-prettier-scenario.ts";
+
+describe("Print Do tests", () => {
+  test("prettified do output is as expected", async () => {
+    await testPrettierScenario(
+      "class A{do { a[long_variable_name] = long_variable_name + 1; } while (another_long_variable_name > another_long_variable_name_2 + 1);}",
+      "class A {\n" +
+        "  do {\n" +
+        "    a[long_variable_name] = long_variable_name + 1;\n" +
+        "  } while (another_long_variable_name > another_long_variable_name_2 + 1);\n" +
+        "}\n",
+      "class A {\n" +
+        "  do {\n" +
+        "    a[long_variable_name] =\n" +
+        "      long_variable_name +\n" +
+        "      1;\n" +
+        "  } while\n" +
+        "    (another_long_variable_name >\n" +
+        "    another_long_variable_name_2 +\n" +
+        "    1);\n" +
+        "}\n",
+    );
+  });
+});