@mpeggroup/mpeg-sdl-parser 4.0.0

package/src/prettier/print-class-declaration.ts

@@ -0,0 +1,99 @@
+import { type AstPath, type Doc, doc } from "prettier";
+import type { AbstractNode } from "../ast/node/abstract-node.ts";
+import {
+  addBreakingWhitespace,
+  addIndentedStatements,
+  addNonBreakingWhitespace,
+} from "./util/print-utils.ts";
+import type { ClassDeclaration } from "../ast/node/class-declaration.ts";
+
+const { fill } = doc.builders;
+
+export function printClassDeclaration(
+  path: AstPath<ClassDeclaration>,
+  print: (path: AstPath<AbstractNode>) => Doc,
+): Doc {
+  const classDeclaration = path.node;
+  let doc: Doc = [];
+
+  if (classDeclaration.alignedModifier !== undefined) {
+    doc.push(
+      path.call(
+        print,
+        "alignedModifier" as keyof ClassDeclaration["alignedModifier"],
+      ),
+    );
+    addNonBreakingWhitespace(doc);
+  }
+
+  if (classDeclaration.expandableModifier !== undefined) {
+    doc.push(
+      path.call(
+        print,
+        "expandableModifier" as keyof ClassDeclaration["expandableModifier"],
+      ),
+    );
+    addNonBreakingWhitespace(doc);
+  }
+
+  if (classDeclaration.abstractKeyword) {
+    doc.push(
+      path.call(
+        print,
+        "abstractKeyword" as keyof ClassDeclaration["abstractKeyword"],
+      ),
+    );
+    addNonBreakingWhitespace(doc);
+  }
+
+  doc.push(
+    path.call(print, "classKeyword"),
+  );
+
+  addNonBreakingWhitespace(doc);
+
+  const identifierDoc: Doc = [];
+  identifierDoc.push(path.call(print, "identifier"));
+
+  if (classDeclaration.parameterList !== undefined) {
+    identifierDoc.push(
+      path.call(
+        print,
+        "parameterList" as keyof ClassDeclaration["parameterList"],
+      ),
+    );
+  }
+  doc.push(identifierDoc);
+  doc = addBreakingWhitespace(doc);
+
+  if (classDeclaration.extendsModifier !== undefined) {
+    doc.push(fill(
+      path.call(
+        print,
+        "extendsModifier" as keyof ClassDeclaration["extendsModifier"],
+      ) as Doc[],
+    ));
+    doc = addBreakingWhitespace(doc);
+  }
+
+  if (classDeclaration.bitModifier !== undefined) {
+    doc.push(fill(
+      path.call(
+        print,
+        "bitModifier" as keyof ClassDeclaration["bitModifier"],
+      ) as Doc[],
+    ));
+    doc = addBreakingWhitespace(doc);
+  }
+
+  const statementsDoc = path.map(print, "statements");
+
+  doc = addIndentedStatements(
+    doc,
+    statementsDoc,
+    path.call(print, "openBracePunctuator"),
+    path.call(print, "closeBracePunctuator"),
+  );
+
+  return fill(doc);
+}

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

@@ -0,0 +1,44 @@
+import type { AstPath, Doc } from "prettier";
+import type { AbstractNode } from "../ast/node/abstract-node.ts";
+import type { ClassDefinition } from "../ast/node/class-definition.ts";
+import { addNonBreakingWhitespace } from "./util/print-utils.ts";
+
+export function printClassDefinition(
+  path: AstPath<ClassDefinition>,
+  print: (path: AstPath<AbstractNode>) => Doc,
+): Doc {
+  const classDefinition = path.node;
+
+  const doc: Doc = [];
+
+  if (classDefinition.legacyKeyword) {
+    doc.push(
+      path.call(
+        print,
+        "legacyKeyword" as keyof ClassDefinition["legacyKeyword"],
+      ),
+    );
+    addNonBreakingWhitespace(doc);
+  }
+
+  doc.push(path.call(print, "classIdentifier"));
+  addNonBreakingWhitespace(doc);
+
+  const identifierDoc = [
+    path.call(print, "identifier"),
+  ];
+
+  if (classDefinition.parameterValueList !== undefined) {
+    identifierDoc.push([
+      path.call(
+        print,
+        "parameterValueList" as keyof ClassDefinition["parameterValueList"],
+      ),
+    ]);
+  }
+
+  doc.push(identifierDoc);
+  doc.push(path.call(print, "semicolonPunctuator"));
+
+  return doc;
+}

package/src/prettier/print-class-member-access.ts

@@ -0,0 +1,13 @@
+import type { AstPath, Doc } from "prettier";
+import type { AbstractNode } from "../ast/node/abstract-node.ts";
+import type { ClassMemberAccess } from "../ast/node/class-member-access.ts";
+
+export function printClassMemberAccess(
+  path: AstPath<ClassMemberAccess>,
+  print: (path: AstPath<AbstractNode>) => Doc,
+): Doc {
+  return [
+    path.call(print, "classMemberAccessOperator"),
+    path.call(print, "memberIdentifier"),
+  ];
+}

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

@@ -0,0 +1,33 @@
+import { type AstPath, type Doc, doc } from "prettier";
+import type { AbstractNode } from "../ast/node/abstract-node.ts";
+import type { ComputedArrayDefinition } from "../ast/node/computed-array-definition.ts";
+import {
+  addBreakingWhitespace,
+  addNonBreakingWhitespace,
+} from "./util/print-utils.ts";
+
+const { fill } = doc.builders;
+
+export function printComputedArrayDefinition(
+  path: AstPath<ComputedArrayDefinition>,
+  print: (path: AstPath<AbstractNode>) => Doc,
+): Doc {
+  let doc: Doc = [];
+
+  doc.push(path.call(print, "computedKeyword"));
+
+  addNonBreakingWhitespace(doc);
+
+  doc.push(path.call(print, "elementaryType"));
+
+  doc = addBreakingWhitespace(doc);
+
+  const identifierClause = [path.call(print, "identifier")];
+
+  identifierClause.push(path.map(print, "dimensions"));
+  identifierClause.push(path.call(print, "semicolonPunctuator"));
+
+  doc.push(identifierClause);
+
+  return fill(doc);
+}

package/src/prettier/print-computed-elementary-type-definition.ts

@@ -0,0 +1,60 @@
+import { type AstPath, type Doc, doc } from "prettier";
+import type { AbstractNode } from "../ast/node/abstract-node.ts";
+import type { ComputedElementaryTypeDefinition } from "../ast/node/computed-elementary-type-definition.ts";
+import {
+  addBreakingWhitespace,
+  addNonBreakingWhitespace,
+} from "./util/print-utils.ts";
+
+const { fill } = doc.builders;
+
+export function printComputedElementaryTypeDefinition(
+  path: AstPath<ComputedElementaryTypeDefinition>,
+  print: (path: AstPath<AbstractNode>) => Doc,
+): Doc {
+  const computedElementaryTypeDefinition = path.node;
+  let doc: Doc = [];
+
+  doc.push(path.call(print, "computedKeyword"));
+  doc = addBreakingWhitespace(doc);
+
+  if (computedElementaryTypeDefinition.constKeyword) {
+    doc.push(
+      path.call(
+        print,
+        "constKeyword" as keyof ComputedElementaryTypeDefinition[
+          "constKeyword"
+        ],
+      ),
+    );
+    doc = addBreakingWhitespace(doc);
+  }
+
+  doc.push(path.call(print, "elementaryType"));
+  doc = addBreakingWhitespace(doc);
+
+  doc.push(path.call(print, "identifier"));
+
+  if (computedElementaryTypeDefinition.value !== undefined) {
+    addNonBreakingWhitespace(doc);
+    doc.push(
+      path.call(
+        print,
+        "assignmentOperator" as keyof ComputedElementaryTypeDefinition[
+          "assignmentOperator"
+        ],
+      ),
+    );
+    doc = addBreakingWhitespace(doc);
+    doc.push(
+      path.call(
+        print,
+        "value" as keyof ComputedElementaryTypeDefinition["value"],
+      ),
+    );
+  }
+
+  doc.push(path.call(print, "semicolonPunctuator"));
+
+  return fill(doc);
+}

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

@@ -0,0 +1,39 @@
+import type { AstPath, Doc } from "prettier";
+import type { AbstractNode } from "../ast/node/abstract-node.ts";
+import { addIndentedStatements } from "./util/print-utils.ts";
+import type { DefaultClause } from "../ast/node/default-clause.ts";
+
+export function printDefaultClause(
+  path: AstPath<DefaultClause>,
+  print: (path: AstPath<AbstractNode>) => Doc,
+): Doc {
+  const defaultClause = path.node;
+  let doc: Doc = [];
+
+  doc.push([
+    path.call(print, "defaultKeyword"),
+    path.call(print, "colonPunctuator"),
+  ]);
+
+  const statementsDoc = path.map(print, "statements");
+
+  if (defaultClause.openBracePunctuator !== undefined) {
+    doc.push(" ");
+    doc = addIndentedStatements(
+      doc,
+      statementsDoc,
+      path.call(
+        print,
+        "openBracePunctuator" as keyof DefaultClause["openBracePunctuator"],
+      ),
+      path.call(
+        print,
+        "closeBracePunctuator" as keyof DefaultClause["closeBracePunctuator"],
+      ),
+    );
+  } else {
+    doc = addIndentedStatements(doc, statementsDoc);
+  }
+
+  return doc;
+}

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

@@ -0,0 +1,31 @@
+import { AstPath, type Doc, doc } from "prettier";
+import {
+  addBreakingWhitespace,
+  addNonBreakingWhitespace,
+} from "./util/print-utils.ts";
+import type { AbstractNode } from "../ast/node/abstract-node.ts";
+import type { DoStatement } from "../ast/node/do-statement.ts";
+
+const { fill } = doc.builders;
+
+export function printDoStatement(
+  path: AstPath<DoStatement>,
+  print: (path: AstPath<AbstractNode>) => Doc,
+): Doc {
+  let doc: Doc = [];
+
+  doc.push(path.call(print, "doKeyword"));
+  addNonBreakingWhitespace(doc);
+  doc.push(path.call(print, "compoundStatement"));
+  addNonBreakingWhitespace(doc);
+  doc.push(path.call(print, "whileKeyword"));
+  doc = addBreakingWhitespace(doc);
+  doc.push([
+    path.call(print, "openParenthesisPunctuator"),
+    path.call(print, "condition"),
+    path.call(print, "closeParenthesisPunctuator"),
+    path.call(print, "semicolonPunctuator"),
+  ]);
+
+  return fill(doc);
+}

package/src/prettier/print-elementary-type-definition.ts

@@ -0,0 +1,108 @@
+import { type AstPath, type Doc, doc } from "prettier";
+import type { AbstractNode } from "../ast/node/abstract-node.ts";
+import type { ElementaryTypeDefinition } from "../ast/node/elementary-type-definition.ts";
+import {
+  addBreakingWhitespace,
+  addNonBreakingWhitespace,
+} from "./util/print-utils.ts";
+
+const { fill } = doc.builders;
+
+export function printElementaryTypeDefinition(
+  path: AstPath<ElementaryTypeDefinition>,
+  print: (path: AstPath<AbstractNode>) => Doc,
+): Doc {
+  const elementaryTypeDefinition = path.node;
+  let doc: Doc = [];
+
+  if (elementaryTypeDefinition.reservedKeyword) {
+    doc.push(
+      path.call(
+        print,
+        "reservedKeyword" as keyof ElementaryTypeDefinition["reservedKeyword"],
+      ),
+    );
+    doc = addBreakingWhitespace(doc);
+  }
+
+  if (elementaryTypeDefinition.legacyKeyword) {
+    doc.push(
+      path.call(
+        print,
+        "legacyKeyword" as keyof ElementaryTypeDefinition["legacyKeyword"],
+      ),
+    );
+    doc = addBreakingWhitespace(doc);
+  }
+
+  if (elementaryTypeDefinition.constKeyword) {
+    doc.push(
+      path.call(
+        print,
+        "constKeyword" as keyof ElementaryTypeDefinition["constKeyword"],
+      ),
+    );
+    doc = addBreakingWhitespace(doc);
+  }
+
+  if (elementaryTypeDefinition.alignedModifier !== undefined) {
+    doc.push(
+      path.call(
+        print,
+        "alignedModifier" as keyof ElementaryTypeDefinition["alignedModifier"],
+      ),
+    );
+    doc = addBreakingWhitespace(doc);
+  }
+
+  doc.push(path.call(print, "elementaryType"));
+  doc.push(path.call(print, "lengthAttribute"));
+
+  if (elementaryTypeDefinition.lookAheadOperator) {
+    doc.push(
+      path.call(
+        print,
+        "lookAheadOperator" as keyof ElementaryTypeDefinition[
+          "lookAheadOperator"
+        ],
+      ),
+    );
+  }
+  doc = addBreakingWhitespace(doc);
+
+  doc.push(path.call(print, "identifier"));
+
+  if (elementaryTypeDefinition.assignmentOperator !== undefined) {
+    addNonBreakingWhitespace(doc);
+    doc.push(
+      path.call(
+        print,
+        "assignmentOperator" as keyof ElementaryTypeDefinition[
+          "assignmentOperator"
+        ],
+      ),
+    );
+    doc = addBreakingWhitespace(doc);
+    doc.push(
+      path.call(print, "value" as keyof ElementaryTypeDefinition["value"]),
+    );
+    if (elementaryTypeDefinition.endValue !== undefined) {
+      doc.push(
+        path.call(
+          print,
+          "rangeOperator" as keyof ElementaryTypeDefinition["rangeOperator"],
+        ),
+      );
+      doc.push(
+        path.call(
+          print,
+          "endValue" as keyof ElementaryTypeDefinition["endValue"],
+        ),
+      );
+    }
+  }
+
+  doc.push(path.call(print, "semicolonPunctuator"));
+
+  return fill(doc);
+}

package/src/prettier/print-elementary-type-output-value.ts

@@ -0,0 +1,13 @@
+import type { AstPath, Doc, doc } from "prettier";
+import type { AbstractNode } from "../ast/node/abstract-node.ts";
+import type { ElementaryTypeOutputValue } from "../ast/node/elementary-type-output-value.ts";
+
+export function printElementaryTypeOutputValue(
+  path: AstPath<ElementaryTypeOutputValue>,
+  print: (path: AstPath<AbstractNode>) => Doc,
+): doc.builders.Doc {
+  return [
+    path.call(print, "elementaryType"),
+    path.call(print, "lengthAttribute"),
+  ];
+}

package/src/prettier/print-elementary-type.ts

@@ -0,0 +1,28 @@
+import { AstPath, type Doc } from "prettier";
+import { addNonBreakingWhitespace } from "./util/print-utils.ts";
+import type { AbstractNode } from "../ast/node/abstract-node.ts";
+import type { ElementaryType } from "../ast/node/elementary-type.ts";
+
+export function printElementaryType(
+  path: AstPath<ElementaryType>,
+  print: (path: AstPath<AbstractNode>) => Doc,
+): Doc {
+  const elementaryType = path.node;
+
+  const doc: Doc = [];
+  if (elementaryType.unsignedQualifierKeyword) {
+    doc.push(
+      path.call(
+        print,
+        "unsignedQualifierKeyword" as keyof ElementaryType[
+          "unsignedQualifierKeyword"
+        ],
+      ),
+    );
+    addNonBreakingWhitespace(doc);
+  }
+
+  doc.push(path.call(print, "typeKeyword"));
+
+  return doc;
+}

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

@@ -0,0 +1,41 @@
+import type { AstPath, Doc } from "prettier";
+import type { AbstractNode } from "../ast/node/abstract-node.ts";
+import type { ExpandableModifier } from "../ast/node/expandable-modifier.ts";
+
+export function printExpandableModifier(
+  path: AstPath<ExpandableModifier>,
+  print: (path: AstPath<AbstractNode>) => Doc,
+): Doc {
+  const expandableModifier = path.node;
+
+  const doc: Doc = [];
+
+  doc.push(
+    path.call(print, "expandableKeyword"),
+  );
+
+  if (expandableModifier.maxClassSize !== undefined) {
+    doc.push(
+      [
+        path.call(
+          print,
+          "openParenthesisPunctuator" as keyof ExpandableModifier[
+            "openParenthesisPunctuator"
+          ],
+        ),
+        path.call(
+          print,
+          "maxClassSize" as keyof ExpandableModifier["maxClassSize"],
+        ),
+        path.call(
+          print,
+          "closeParenthesisPunctuator" as keyof ExpandableModifier[
+            "closeParenthesisPunctuator"
+          ],
+        ),
+      ],
+    );
+  }
+
+  return doc;
+}

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

@@ -0,0 +1,29 @@
+import type { AstPath, Doc } from "prettier";
+import type { AbstractNode } from "../ast/node/abstract-node.ts";
+import type { ExtendsModifier } from "../ast/node/extends-modifier.ts";
+import { addNonBreakingWhitespace } from "./util/print-utils.ts";
+
+export function printExtendsModifier(
+  path: AstPath<ExtendsModifier>,
+  print: (path: AstPath<AbstractNode>) => Doc,
+): Doc {
+  const mapEntryList = path.node;
+
+  const doc: Doc = [];
+
+  doc.push(path.call(print, "extendsKeyword"));
+  addNonBreakingWhitespace(doc);
+
+  doc.push(path.call(print, "identifier"));
+
+  if (mapEntryList.parameterValueList !== undefined) {
+    doc.push(
+      path.call(
+        print,
+        "parameterValueList" as keyof ExtendsModifier["parameterValueList"],
+      ),
+    );
+  }
+
+  return doc;
+}

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

@@ -0,0 +1,64 @@
+import { AstPath, type Doc } from "prettier";
+import {
+  addBreakingWhitespace,
+  addNonBreakingWhitespace,
+} from "./util/print-utils.ts";
+import type { AbstractNode } from "../ast/node/abstract-node.ts";
+import type { ForStatement } from "../ast/node/for-statement.ts";
+
+export function printForStatement(
+  path: AstPath<ForStatement>,
+  print: (path: AstPath<AbstractNode>) => Doc,
+): Doc {
+  const forStatement = path.node;
+  const doc: Doc = [];
+  let subDoc: Doc = [];
+
+  doc.push(path.call(print, "forKeyword"));
+  addNonBreakingWhitespace(doc);
+
+  subDoc.push(path.call(print, "openParenthesisPunctuator"));
+
+  if (forStatement.expression1 !== undefined) {
+    subDoc.push(
+      path.call(print, "expression1" as keyof ForStatement["expression1"]),
+    );
+  } else if (forStatement.computedElementaryDefinition !== undefined) {
+    subDoc.push(
+      path.call(
+        print,
+        "computedElementaryDefinition" as keyof ForStatement[
+          "computedElementaryDefinition"
+        ],
+      ),
+    );
+  } else if (forStatement.semicolon1Punctuator !== undefined) {
+    subDoc.push(
+      path.call(
+        print,
+        "semicolon1Punctuator" as keyof ForStatement["semicolon1Punctuator"],
+      ),
+    );
+  }
+
+  if (forStatement.expression2 !== undefined) {
+    subDoc = addBreakingWhitespace(subDoc);
+    subDoc.push(
+      path.call(print, "expression2" as keyof ForStatement["expression2"]),
+    );
+  }
+  subDoc.push(path.call(print, "semicolon2Punctuator"));
+  if (forStatement.expression3 !== undefined) {
+    subDoc = addBreakingWhitespace(subDoc);
+    subDoc.push(
+      path.call(print, "expression3" as keyof ForStatement["expression3"]),
+    );
+  }
+  subDoc.push(path.call(print, "closeParenthesisPunctuator"));
+  addNonBreakingWhitespace(subDoc);
+
+  doc.push(subDoc);
+  doc.push(path.call(print, "statement"));
+
+  return doc;
+}

package/src/prettier/print-identifier.ts

@@ -0,0 +1,10 @@
+import type { AstPath, Doc } from "prettier";
+import type { Identifier } from "../ast/node/identifier.ts";
+import type { AbstractNode } from "../../index.ts";
+
+export function printIdentifier(
+  path: AstPath<Identifier>,
+  print: (path: AstPath<AbstractNode>) => Doc,
+): Doc {
+  return path.call(print, "children", 0);
+}