@mpeggroup/mpeg-sdl-parser 4.0.0

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

@@ -0,0 +1,76 @@
+import { AstPath, type Doc } from "prettier";
+import type { AbstractNode } from "../ast/node/abstract-node.ts";
+import type { IfStatement } from "../ast/node/if-statement.ts";
+import {
+  addIndentedStatements,
+  addNonBreakingWhitespace,
+  addTrailingHardline,
+} from "./util/print-utils.ts";
+import { StatementKind } from "../ast/node/enum/statement-kind.ts";
+import { isStatement } from "../ast/util/types.ts";
+
+export function printIfStatement(
+  path: AstPath<IfStatement>,
+  print: (_path: AstPath<AbstractNode>) => Doc,
+): Doc {
+  const ifStatement = path.node;
+
+  let doc: Doc = [];
+
+  doc.push(path.call(print, "ifKeyword"));
+  addNonBreakingWhitespace(doc);
+
+  doc.push([
+    path.call(print, "openParenthesisPunctuator"),
+    path.call(print, "condition"),
+    path.call(print, "closeParenthesisPunctuator"),
+  ]);
+
+  addNonBreakingWhitespace(doc);
+
+  const ifSubStatement = ifStatement.ifStatement;
+  if (
+    isStatement(ifSubStatement) &&
+    (ifSubStatement.statementKind === StatementKind.COMPOUND)
+  ) {
+    doc.push(path.call(print, "ifStatement"));
+  } else {
+    doc = addIndentedStatements(doc, [path.call(print, "ifStatement")]);
+  }
+
+  if (ifStatement.elseKeyword === undefined) {
+    return doc;
+  }
+
+  doc = addTrailingHardline(doc);
+
+  if (!Array.isArray(doc)) {
+    doc = [doc];
+  }
+
+  doc.push(
+    path.call(print, "elseKeyword" as keyof IfStatement["elseKeyword"]),
+  );
+  addNonBreakingWhitespace(doc);
+
+  const elseSubStatement = ifStatement.elseStatement!;
+  if (
+    isStatement(elseSubStatement) &&
+    (elseSubStatement.statementKind !== StatementKind.COMPOUND) &&
+    (elseSubStatement.statementKind !== StatementKind.IF)
+  ) {
+    doc = addIndentedStatements(
+      doc,
+      [path.call(
+        print,
+        "elseStatement" as keyof IfStatement["elseStatement"],
+      )],
+    );
+  } else {
+    doc.push(
+      path.call(print, "elseStatement" as keyof IfStatement["elseStatement"]),
+    );
+  }
+
+  return doc;
+}

package/src/prettier/print-length-attribute.ts

@@ -0,0 +1,14 @@
+import type { AstPath, Doc } from "prettier";
+import type { AbstractNode } from "../ast/node/abstract-node.ts";
+import type { LengthAttribute } from "../ast/node/length-attribute.ts";
+
+export function printLengthAttribute(
+  path: AstPath<LengthAttribute>,
+  print: (path: AstPath<AbstractNode>) => Doc,
+): Doc {
+  return [
+    path.call(print, "openParenthesisPunctuator"),
+    path.call(print, "length"),
+    path.call(print, "closeParenthesisPunctuator"),
+  ];
+}

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

@@ -0,0 +1,75 @@
+import type { AstPath, Doc } from "prettier";
+import type { AbstractNode } from "../ast/node/abstract-node.ts";
+import type { MapDeclaration } from "../ast/node/map-declaration.ts";
+import {
+  addIndentedStatements,
+  addNonBreakingWhitespace,
+} from "./util/print-utils.ts";
+
+export function printMapDeclaration(
+  path: AstPath<MapDeclaration>,
+  print: (path: AstPath<AbstractNode>) => Doc,
+): Doc {
+  const mapDeclaration = path.node;
+  const doc: Doc = [];
+
+  doc.push(path.call(print, "mapKeyword"));
+
+  addNonBreakingWhitespace(doc);
+
+  doc.push(path.call(print, "identifier"));
+
+  addNonBreakingWhitespace(doc);
+
+  const subDoc: Doc = [
+    path.call(print, "openParenthesisPunctuator"),
+  ];
+
+  if (mapDeclaration.outputElementaryType !== undefined) {
+    subDoc.push(
+      path.call(
+        print,
+        "outputElementaryType" as keyof MapDeclaration["outputElementaryType"],
+      ),
+    );
+  } else if (mapDeclaration.outputClassIdentifier !== undefined) {
+    subDoc.push(
+      path.call(
+        print,
+        "outputClassIdentifier" as keyof MapDeclaration[
+          "outputClassIdentifier"
+        ],
+      ),
+    );
+  }
+
+  subDoc.push(path.call(print, "closeParenthesisPunctuator"));
+
+  doc.push(subDoc);
+  addNonBreakingWhitespace(doc);
+
+  const entriesSubDoc: Doc = [];
+
+  for (let i = 0; i < mapDeclaration.mapEntries.length; i++) {
+    const entrySubDoc: Doc = [];
+
+    entrySubDoc.push(path.call(print, "mapEntries", i));
+
+    if (mapDeclaration.commaPunctuators) {
+      if (i < mapDeclaration.commaPunctuators.length) {
+        entrySubDoc.push(
+          path.call(print, "commaPunctuators", i),
+        );
+      }
+    }
+
+    entriesSubDoc.push(entrySubDoc);
+  }
+
+  return addIndentedStatements(
+    doc,
+    entriesSubDoc,
+    path.call(print, "openBracePunctuator"),
+    path.call(print, "closeBracePunctuator"),
+  );
+}

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

@@ -0,0 +1,67 @@
+import type { AstPath, Doc } from "prettier";
+import type { AbstractNode } from "../ast/node/abstract-node.ts";
+import type { MapDefinition } from "../ast/node/map-definition.ts";
+import {
+  addBreakingWhitespace,
+  addNonBreakingWhitespace,
+} from "./util/print-utils.ts";
+
+export function printMapDefinition(
+  path: AstPath<MapDefinition>,
+  print: (path: AstPath<AbstractNode>) => Doc,
+): Doc {
+  const mapDefinition = path.node;
+  let doc: Doc = [];
+
+  if (mapDefinition.reservedKeyword) {
+    doc.push(
+      path.call(
+        print,
+        "reservedKeyword" as keyof MapDefinition["reservedKeyword"],
+      ),
+    );
+    addNonBreakingWhitespace(doc);
+  }
+
+  if (mapDefinition.legacyKeyword) {
+    doc.push(
+      path.call(print, "legacyKeyword" as keyof MapDefinition["legacyKeyword"]),
+    );
+    addNonBreakingWhitespace(doc);
+  }
+
+  if (mapDefinition.elementaryType !== undefined) {
+    doc.push(
+      path.call(
+        print,
+        "elementaryType" as keyof MapDefinition["elementaryType"],
+      ),
+    );
+  } else if (mapDefinition.classIdentifier !== undefined) {
+    doc.push(
+      path.call(
+        print,
+        "classIdentifier" as keyof MapDefinition["classIdentifier"],
+      ),
+    );
+  }
+
+  doc = addBreakingWhitespace(doc);
+
+  const subDoc: Doc = [];
+
+  subDoc.push(path.call(print, "relationalLessThanPunctuator"));
+  subDoc.push(path.call(print, "mapIdentifier"));
+  subDoc.push(path.call(print, "relationalGreaterThanPunctuator"));
+
+  doc.push(subDoc);
+
+  doc = addBreakingWhitespace(doc);
+
+  doc.push([
+    path.call(print, "identifier"),
+    path.call(print, "semicolonPunctuator"),
+  ]);
+
+  return doc;
+}

package/src/prettier/print-map-entry.ts

@@ -0,0 +1,22 @@
+import { AstPath, type Doc, doc } from "prettier";
+import { addNonBreakingWhitespace } from "./util/print-utils.ts";
+import type { AbstractNode } from "../ast/node/abstract-node.ts";
+import type { MapEntry } from "../ast/node/map-entry.ts";
+
+export function printMapEntry(
+  path: AstPath<MapEntry>,
+  print: (path: AstPath<AbstractNode>) => Doc,
+): doc.builders.Doc {
+  const doc: Doc = [];
+
+  doc.push([
+    path.call(print, "inputValue"),
+    path.call(print, "commaPunctuator"),
+  ]);
+
+  addNonBreakingWhitespace(doc);
+
+  doc.push(path.call(print, "outputValue"));
+
+  return doc;
+}

package/src/prettier/print-number-literal.ts

@@ -0,0 +1,84 @@
+import { type AstPath, type Doc, doc } from "prettier";
+import { NumberLiteralKind } from "../ast/node/enum/number-literal-kind.ts";
+import type { NumberLiteral } from "../ast/node/number-literal.ts";
+import type { Token } from "../ast/node/token.ts";
+import { isMissingError, isUnexpectedError } from "../ast/util/types.ts";
+import type { AbstractNode } from "../ast/node/abstract-node.ts";
+import { InternalScannerError } from "../scanner-error.ts";
+
+const { join } = doc.builders;
+
+function printMultipleCharacterNumberLiteral(
+  path: AstPath<NumberLiteral>,
+  print: (path: AstPath<AbstractNode>) => Doc,
+): Doc {
+  const multipleCharacterNumberLiteral = path.node;
+
+  const multipleCharacterNumberLiteralsDoc: Doc = [];
+  let currentLiterals: Doc[] = [];
+  let opened = false;
+  let containsContent = false;
+
+  multipleCharacterNumberLiteral.literals.forEach((literal, index) => {
+    if (isMissingError(literal)) {
+      return;
+    }
+    if (isUnexpectedError(literal)) {
+      currentLiterals.push(path.call(print, "literals", index));
+      return;
+    }
+    const literalToken = literal as Token;
+    if (literalToken.text === "'") {
+      if (!opened) {
+        currentLiterals.push(path.call(print, "literals", index));
+        opened = true;
+      } else {
+        currentLiterals.push(path.call(print, "literals", index));
+
+        // avoid empty multiple character number literals after the first one
+        if (
+          (multipleCharacterNumberLiteralsDoc.length === 0) || containsContent
+        ) {
+          multipleCharacterNumberLiteralsDoc.push(currentLiterals);
+        }
+
+        // reset state
+        currentLiterals = [];
+        containsContent = false;
+        opened = false;
+      }
+    } else if (literalToken.text.length > 0) {
+      currentLiterals.push(literalToken.text);
+      containsContent = true;
+    }
+  });
+
+  return join(
+    " ",
+    multipleCharacterNumberLiteralsDoc,
+  );
+}
+export function printNumberLiteral(
+  path: AstPath<NumberLiteral>,
+  print: (path: AstPath<AbstractNode>) => Doc,
+): Doc {
+  const numberLiteral = path.node;
+  const numberLiteralKind = numberLiteral.numberLiteralKind;
+
+  switch (numberLiteralKind) {
+    case NumberLiteralKind.BINARY:
+    case NumberLiteralKind.HEXADECIMAL:
+    case NumberLiteralKind.INTEGER:
+    case NumberLiteralKind.DECIMAL:
+    case NumberLiteralKind.FLOATING_POINT:
+      return path.call(print, "literals", 0);
+    case NumberLiteralKind.MULTIPLE_CHARACTER:
+      return printMultipleCharacterNumberLiteral(path, print);
+    default: {
+      const exhaustiveCheck: never = numberLiteralKind;
+      throw new InternalScannerError(
+        "Unreachable code reached, numberLiteralKind == " + exhaustiveCheck,
+      );
+    }
+  }
+}

package/src/prettier/print-parameter-list.ts

@@ -0,0 +1,20 @@
+import type { AstPath, Doc, doc } from "prettier";
+import type { AbstractNode } from "../ast/node/abstract-node.ts";
+import type { ParameterList } from "../ast/node/parameter-list.ts";
+import { interleaveCommaSeparatorDocs } from "./util/print-utils.ts";
+
+export function printParameterList(
+  path: AstPath<ParameterList>,
+  print: (path: AstPath<AbstractNode>) => Doc,
+): doc.builders.Doc {
+  const parametersDoc = interleaveCommaSeparatorDocs(
+    path.map(print, "parameters"),
+    path.map(print, "commaPunctuators"),
+  );
+
+  return [
+    path.call(print, "openParenthesisPunctuator"),
+    parametersDoc,
+    path.call(print, "closeParenthesisPunctuator"),
+  ];
+}

package/src/prettier/print-parameter-value-list.ts

@@ -0,0 +1,20 @@
+import type { AstPath, Doc, doc } from "prettier";
+import type { AbstractNode } from "../ast/node/abstract-node.ts";
+import type { ParameterValueList } from "../ast/node/parameter-value-list.ts";
+import { interleaveCommaSeparatorDocs } from "./util/print-utils.ts";
+
+export function printParameterValueList(
+  path: AstPath<ParameterValueList>,
+  print: (path: AstPath<AbstractNode>) => Doc,
+): doc.builders.Doc {
+  const parameterValuesDoc = interleaveCommaSeparatorDocs(
+    path.map(print, "values"),
+    path.map(print, "commaPunctuators"),
+  );
+
+  return [
+    path.call(print, "openParenthesisPunctuator"),
+    parameterValuesDoc,
+    path.call(print, "closeParenthesisPunctuator"),
+  ];
+}

package/src/prettier/print-parameter.ts

@@ -0,0 +1,34 @@
+import { AstPath, type Doc, doc } from "prettier";
+import { addNonBreakingWhitespace } from "./util/print-utils.ts";
+import type { AbstractNode } from "../ast/node/abstract-node.ts";
+import type { Parameter } from "../ast/node/parameter.ts";
+
+export function printParameter(
+  path: AstPath<Parameter>,
+  print: (path: AstPath<AbstractNode>) => Doc,
+): doc.builders.Doc {
+  const parameter = path.node;
+  const doc: Doc = [];
+
+  if (parameter.classIdentifier !== undefined) {
+    doc.push(
+      path.call(
+        print,
+        "classIdentifier" as keyof Parameter["classIdentifier"],
+      ),
+    );
+  } else if (parameter.elementaryType !== undefined) {
+    doc.push(
+      path.call(
+        print,
+        "elementaryType" as keyof Parameter["elementaryType"],
+      ),
+    );
+  }
+
+  addNonBreakingWhitespace(doc);
+
+  doc.push(path.call(print, "identifier"));
+
+  return doc;
+}

package/src/prettier/print-specification.ts

@@ -0,0 +1,51 @@
+import { AstPath, type Doc, doc } from "prettier";
+import type { AbstractNode } from "../ast/node/abstract-node.ts";
+import type { AbstractStatement } from "../ast/node/abstract-statement.ts";
+import { NodeKind } from "../ast/node/enum/node-kind.ts";
+import { StatementKind } from "../ast/node/enum/statement-kind.ts";
+import type { Specification } from "../ast/node/specification.ts";
+import {
+  addTrailingHardline,
+  endsWithHardline,
+  removeLeadingBlanklines,
+} from "./util/print-utils.ts";
+
+const { hardline } = doc.builders;
+
+export function printSpecification(
+  path: AstPath<Specification>,
+  print: (path: AstPath<AbstractNode>) => Doc,
+): Doc {
+  const doc: Doc = [];
+  const node = path.node;
+  let previousStatementKind: StatementKind | undefined;
+
+  for (let i = 0; i < node.children.length; i++) {
+    const globalNode = node.children[i];
+
+    if (globalNode.nodeKind === NodeKind.STATEMENT) {
+      const statementKind = (globalNode as AbstractStatement).statementKind;
+      if (
+        (i > 0) &&
+        (previousStatementKind !== undefined) &&
+        ((statementKind !== previousStatementKind) ||
+          (statementKind !== StatementKind.COMPUTED_ELEMENTARY_TYPE_DEFINITION))
+      ) {
+        doc.push(hardline);
+      }
+      previousStatementKind = statementKind;
+    }
+
+    let globalDoc = path.call(print, "children", i);
+
+    globalDoc = removeLeadingBlanklines(globalDoc);
+
+    if (!endsWithHardline(globalDoc)) {
+      globalDoc = addTrailingHardline(globalDoc);
+    }
+
+    doc.push(globalDoc);
+  }
+
+  return doc;
+}

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

@@ -0,0 +1,114 @@
+import { type AstPath, type Doc, doc } from "prettier";
+import type { AbstractNode } from "../ast/node/abstract-node.ts";
+import type { StringDefinition } from "../ast/node/string-definition.ts";
+import {
+  addBreakingWhitespace,
+  addNonBreakingWhitespace,
+} from "./util/print-utils.ts";
+
+const { fill } = doc.builders;
+
+export function printStringDefinition(
+  path: AstPath<StringDefinition>,
+  print: (path: AstPath<AbstractNode>) => Doc,
+): Doc {
+  const stringDefinition = path.node;
+
+  const subDoc1: Doc = [];
+  if (stringDefinition.reservedKeyword) {
+    subDoc1.push(
+      path.call(
+        print,
+        "reservedKeyword" as keyof StringDefinition["reservedKeyword"],
+      ),
+    );
+    addNonBreakingWhitespace(subDoc1);
+  }
+
+  if (stringDefinition.legacyKeyword) {
+    subDoc1.push(
+      path.call(
+        print,
+        "legacyKeyword" as keyof StringDefinition["legacyKeyword"],
+      ),
+    );
+    addNonBreakingWhitespace(subDoc1);
+  }
+
+  if (stringDefinition.constKeyword) {
+    subDoc1.push(
+      path.call(
+        print,
+        "constKeyword" as keyof StringDefinition["constKeyword"],
+      ),
+    );
+    addNonBreakingWhitespace(subDoc1);
+  }
+
+  if (stringDefinition.alignedModifier !== undefined) {
+    subDoc1.push(
+      path.call(
+        print,
+        "alignedModifier" as keyof StringDefinition["alignedModifier"],
+      ),
+    );
+    addNonBreakingWhitespace(subDoc1);
+  }
+
+  subDoc1.push(path.call(print, "stringVariableKindToken"));
+
+  let doc: Doc[] = [];
+
+  doc.push(subDoc1);
+  doc = addBreakingWhitespace(doc);
+
+  const subDoc2: Doc = [];
+
+  subDoc2.push(path.call(print, "identifier"));
+
+  if (stringDefinition.assignmentPunctuator !== undefined) {
+    addNonBreakingWhitespace(subDoc2);
+    subDoc2.push(
+      path.call(
+        print,
+        "assignmentPunctuator" as keyof StringDefinition[
+          "assignmentPunctuator"
+        ],
+      ),
+    );
+    doc.push(subDoc2);
+
+    doc = addBreakingWhitespace(doc);
+
+    const stringLiteralsDoc = path.call(
+      print,
+      "stringLiteral" as keyof StringDefinition["stringLiteral"],
+    );
+
+    if (Array.isArray(stringLiteralsDoc)) {
+      stringLiteralsDoc.forEach((stringLiteralDoc, index) => {
+        if (index > 0) {
+          doc = addBreakingWhitespace(doc);
+        }
+        if (index === (stringLiteralsDoc.length - 1)) {
+          doc.push([
+            stringLiteralDoc,
+            path.call(print, "semicolonPunctuator"),
+          ]);
+        } else {
+          doc.push(stringLiteralDoc);
+        }
+      });
+    } else {
+      doc.push([
+        stringLiteralsDoc,
+        path.call(print, "semicolonPunctuator"),
+      ]);
+    }
+  } else {
+    subDoc2.push(path.call(print, "semicolonPunctuator"));
+    doc.push(subDoc2);
+  }
+
+  return fill(doc);
+}

package/src/prettier/print-string-literal.ts

@@ -0,0 +1,57 @@
+import { AstPath, type Doc } from "prettier";
+import type { StringLiteral } from "../ast/node/string-literal.ts";
+import { isMissingError, isUnexpectedError } from "../ast/util/types.ts";
+import type { AbstractNode, Token } from "../../index.ts";
+
+export function printStringLiteral(
+  path: AstPath<StringLiteral>,
+  print: (path: AstPath<AbstractNode>) => Doc,
+): Doc {
+  const stringLiteral = path.node;
+
+  const doc: Doc = [];
+  let currentLiteralDoc: Doc[] = [];
+  let opened = false;
+  let containsContent = false;
+
+  stringLiteral.literals.forEach((literal, index) => {
+    if (isMissingError(literal)) {
+      return;
+    }
+    if (isUnexpectedError(literal)) {
+      currentLiteralDoc.push(path.call(print, "literals", index));
+      return;
+    }
+    const literalToken = literal as Token;
+
+    if (literalToken.text === '"') {
+      if (!opened) {
+        currentLiteralDoc.push(path.call(print, "literals", index));
+        opened = true;
+      } else {
+        currentLiteralDoc.push(path.call(print, "literals", index));
+
+        // skip any empty literals after the first literal
+        if ((doc.length === 0) || containsContent) {
+          doc.push(currentLiteralDoc.join(""));
+        }
+
+        // reset state
+        currentLiteralDoc = [];
+        containsContent = false;
+        opened = false;
+      }
+    } else if (literalToken.text === "u") {
+      if (opened) {
+        currentLiteralDoc.push(literalToken.text);
+        containsContent = true;
+      } else {
+        currentLiteralDoc.push(path.call(print, "literals", index));
+      }
+    } else if (literalToken.text.length > 0) {
+      currentLiteralDoc.push(literalToken.text);
+      containsContent = true;
+    }
+  });
+  return doc;
+}

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

@@ -0,0 +1,46 @@
+import { AstPath, type Doc } from "prettier";
+import {
+  addIndentedStatements,
+  addNonBreakingWhitespace,
+} from "./util/print-utils.ts";
+import type { AbstractNode } from "../ast/node/abstract-node.ts";
+import type { SwitchStatement } from "../ast/node/switch-statement.ts";
+
+export function printSwitchStatement(
+  path: AstPath<SwitchStatement>,
+  print: (path: AstPath<AbstractNode>) => Doc,
+): Doc {
+  const switchStatement = path.node;
+
+  const doc: Doc = [];
+
+  doc.push(path.call(print, "switchKeyword"));
+  addNonBreakingWhitespace(doc);
+  doc.push([
+    path.call(print, "openParenthesisPunctuator"),
+    path.call(print, "expression"),
+    path.call(print, "closeParenthesisPunctuator"),
+  ]);
+
+  addNonBreakingWhitespace(doc);
+
+  const casesDoc: Doc = [];
+
+  casesDoc.push(
+    ...path.map(print, "caseClauses"),
+  );
+
+  if (switchStatement.defaultClause !== undefined) {
+    casesDoc.push(path.call(
+      print,
+      "defaultClause" as keyof SwitchStatement["defaultClause"],
+    ));
+  }
+
+  return addIndentedStatements(
+    doc,
+    casesDoc,
+    path.call(print, "openBracePunctuator"),
+    path.call(print, "closeBracePunctuator"),
+  );
+}

package/src/prettier/print-token.ts

@@ -0,0 +1,7 @@
+import type { AstPath, Doc } from "prettier";
+import type { Token } from "../ast/node/token.ts";
+
+export function printToken(path: AstPath<Token>): Doc {
+  const node = path.node;
+  return node.text;
+}