@mpeggroup/mpeg-sdl-parser 4.0.0

package/src/location.ts

@@ -0,0 +1,13 @@
+/**
+ * Represents a location within a text document.
+ *
+ * @interface Location
+ * @property {number} row - The one-based row number in the text document.
+ * @property {number} column - The one-based column number in the text document.
+ * @property {number} position - The zero-based position within the entire text.
+ */
+export interface Location {
+  readonly row: number;
+  readonly column: number;
+  readonly position: number;
+}

package/src/parse-helper.ts

@@ -0,0 +1,93 @@
+import { type Tree } from "@lezer/common";
+import type { NodeHandler } from "./ast/visitor/node-handler.ts";
+import type { Specification } from "./ast/node/specification.ts";
+import { SyntaxError } from "./scanner-error.ts";
+import { TraversingVisitor } from "./ast/visitor/traversing-visitor.ts";
+import * as prettier from "prettier/standalone.js";
+import { prettierPluginSdl } from "./prettier/prettier-plugin-sdl.ts";
+import type { Plugin } from "prettier";
+import { Text } from "@codemirror/state";
+import type { AbstractNode } from "./ast/node/abstract-node.ts";
+import { SdlStringInput } from "./lezer/sdl-string-input.ts";
+import { createSyntaxErrorFromTextAndCursor } from "./lezer/create-syntax-error-from-text-and-cursor.ts";
+
+/**
+ * Create a dynamic prettier plugin for SDL using the pre-parsed AST.
+ */
+function getPreParsedAstPrettierPlugin(
+  specification: Specification,
+): Plugin<AbstractNode> {
+  const prettierPluginSdlParser = prettierPluginSdl.parsers!.sdl!;
+
+  return {
+    languages: prettierPluginSdl.languages,
+    parsers: {
+      sdl: {
+        astFormat: prettierPluginSdlParser.astFormat,
+        parse: () => specification,
+        locStart: prettierPluginSdlParser.locStart,
+        locEnd: prettierPluginSdlParser.locEnd,
+      },
+    },
+    printers: prettierPluginSdl.printers,
+  };
+}
+
+/**
+ * Return a collated list of syntax errors from the parse tree.
+ *
+ * @param parseTree The parse tree generated from the source string.
+ * @param sdlStringInput The SDL source `StringInput`.
+ */
+export function collateSyntaxErrors(
+  parseTree: Tree,
+  sdlStringInput: SdlStringInput,
+): SyntaxError[] {
+  const text = Text.of(
+    sdlStringInput.read(0, sdlStringInput.length).split("\n"),
+  );
+
+  const syntaxErrors = [];
+  const cursor = parseTree.cursor();
+  do {
+    if (cursor.type.isError) {
+      syntaxErrors.push(createSyntaxErrorFromTextAndCursor(text, cursor));
+    }
+  } while (cursor.next());
+
+  return syntaxErrors;
+}
+
+/**
+ * Prettify the source.
+ *
+ * @param specification The specification to be used for the pre-parsed AST.
+ * @param sdlStringInput The SDL source `StringInput`.
+ * @param lineWidth The line width to format to.
+ */
+export function prettyPrint(
+  specification: Specification,
+  sdlStringInput: SdlStringInput,
+  lineWidth = 80,
+): Promise<string> {
+  return prettier.format(sdlStringInput.read(0, sdlStringInput.length), {
+    parser: "sdl",
+    plugins: [getPreParsedAstPrettierPlugin(specification)],
+    printWidth: lineWidth,
+  });
+}
+
+/**
+ * Dispatch a node handler to visit all nodes in the abstract syntax tree.
+ *
+ * @param specification The specification to be traversed.
+ * @param nodeHandler The handler to perform operations on each node.
+ */
+export function dispatchNodeHandler(
+  specification: Specification,
+  nodeHandler: NodeHandler,
+) {
+  const traversingVisitor = new TraversingVisitor(nodeHandler);
+
+  traversingVisitor.visit(specification);
+}

package/src/prettier/prettier-plugin-sdl.ts

@@ -0,0 +1,89 @@
+import type { Parser, Plugin, Printer, SupportLanguage } from "prettier";
+import { printAbstractNode } from "./print-abstract-node.ts";
+import type { AbstractNode } from "../ast/node/abstract-node.ts";
+import { createLenientSdlParser } from "../lezer/create-sdl-parser.ts";
+import { buildAst } from "../ast/build-ast.ts";
+import { SdlStringInput } from "../lezer/sdl-string-input.ts";
+import {
+  isCompositeNode,
+  isToken,
+  type RequiredNode,
+} from "../ast/util/types.ts";
+import type { Token } from "../ast/node/token.ts";
+import { InternalScannerError } from "../scanner-error.ts";
+import { NodeKind } from "../ast/node/enum/node-kind.ts";
+
+const languages: SupportLanguage[] = [
+  {
+    name: "sdl",
+    parsers: ["sdl"],
+  },
+];
+
+const parsers: Record<string, Parser<RequiredNode<AbstractNode>>> = {
+  sdl: {
+    astFormat: "sdl",
+    parse: (sdlSpecification: string) => {
+      const sdlStringInput = new SdlStringInput(sdlSpecification);
+      const sdlParser = createLenientSdlParser();
+      const parseTree = sdlParser.parse(sdlSpecification);
+
+      return buildAst(parseTree, sdlStringInput, true);
+    },
+    locStart: (node: RequiredNode<AbstractNode>) => {
+      let token: Token;
+      if (isCompositeNode(node)) {
+        if (!node.startToken) {
+          throw new InternalScannerError(
+            "Composite node does not have a start token.",
+          );
+        }
+        token = node.startToken;
+      } else if (isToken(node)) {
+        token = node;
+      } else {
+        throw new InternalScannerError(
+          "Unsupported node for prettierPluginSdl: " + NodeKind[node.nodeKind],
+        );
+      }
+      return (token.leadingTrivia &&
+          (token.leadingTrivia.length > 0))
+        ? token.leadingTrivia[0].location.position
+        : token.getLocation().position;
+    },
+    locEnd: (node: RequiredNode<AbstractNode>) => {
+      let token: Token;
+      if (isCompositeNode(node)) {
+        if (!node.endToken) {
+          throw new InternalScannerError(
+            "Composite node does not have an end token.",
+          );
+        }
+        token = node.endToken;
+      } else if (isToken(node)) {
+        token = node;
+      } else {
+        throw new InternalScannerError(
+          "Unsupported node for prettierPluginSdl: " + NodeKind[node.nodeKind],
+        );
+      }
+      return (token.trailingTrivia &&
+          (token.trailingTrivia.length > 0))
+        ? token.trailingTrivia[token.trailingTrivia.length - 1].location
+          .position
+        : token.getLocation().position;
+    },
+  },
+};
+
+const printers: Record<string, Printer<RequiredNode<AbstractNode>>> = {
+  "sdl": {
+    print: printAbstractNode,
+  },
+};
+
+export const prettierPluginSdl: Plugin = {
+  languages,
+  parsers,
+  printers,
+};

package/src/prettier/print-abstract-array-dimension.ts

@@ -0,0 +1,84 @@
+import type { AstPath, Doc } from "prettier";
+import type { AbstractArrayDimension } from "../ast/node/abstract-array-dimension.ts";
+import type { AbstractNode } from "../ast/node/abstract-node.ts";
+import { ArrayDimensionKind } from "../ast/node/enum/array-dimension-kind.ts";
+import type { ExplicitArrayDimension } from "../ast/node/explicit-array-dimension.ts";
+import type { ImplicitArrayDimension } from "../ast/node/implicit-array-dimension.ts";
+import type { PartialArrayDimension } from "../ast/node/partial-array-dimension.ts";
+import { InternalScannerError } from "../scanner-error.ts";
+
+export function printAbstractArrayDimension(
+  path: AstPath<AbstractArrayDimension>,
+  print: (path: AstPath<AbstractNode>) => Doc,
+): Doc {
+  const { arrayDimensionKind } = path.node;
+
+  switch (arrayDimensionKind) {
+    case ArrayDimensionKind.EXPLICIT: {
+      return [
+        path.call(print, "openBracketPunctuator"),
+        (path as AstPath<ExplicitArrayDimension>).call(print, "size"),
+        path.call(print, "closeBracketPunctuator"),
+      ];
+    }
+    case ArrayDimensionKind.PARTIAL: {
+      return [
+        path.call(print, "openBracketPunctuator"),
+        (path as AstPath<PartialArrayDimension>).call(
+          print,
+          "innerOpenBracketPunctuator",
+        ),
+        (path as AstPath<PartialArrayDimension>).call(print, "index"),
+        (path as AstPath<PartialArrayDimension>).call(
+          print,
+          "innerCloseBracketPunctuator",
+        ),
+        path.call(print, "closeBracketPunctuator"),
+      ];
+    }
+    case ArrayDimensionKind.IMPLICIT: {
+      const node = path.node as ImplicitArrayDimension;
+      const doc: Doc = [];
+
+      doc.push(
+        path.call(print, "openBracketPunctuator"),
+      );
+
+      if (node.rangeStart !== undefined) {
+        doc.push(
+          path.call(
+            print,
+            "rangeStart" as keyof ImplicitArrayDimension["rangeStart"],
+          ),
+        );
+      }
+
+      if (node.rangeOperator !== undefined) {
+        doc.push(
+          path.call(
+            print,
+            "rangeOperator" as keyof ImplicitArrayDimension["rangeOperator"],
+          ),
+        );
+        doc.push(
+          path.call(
+            print,
+            "rangeEnd" as keyof ImplicitArrayDimension["rangeEnd"],
+          ),
+        );
+      }
+
+      doc.push(
+        path.call(print, "closeBracketPunctuator"),
+      );
+      return doc;
+    }
+
+    default: {
+      const exhaustiveCheck: never = arrayDimensionKind;
+      throw new InternalScannerError(
+        "Unreachable code reached, arrayDimensionKind == " + exhaustiveCheck,
+      );
+    }
+  }
+}

package/src/prettier/print-abstract-class-id.ts

@@ -0,0 +1,53 @@
+import type { AstPath, Doc } from "prettier";
+import type { AbstractClassId } from "../ast/node/abstract-class-id.ts";
+import type { AbstractNode } from "../ast/node/abstract-node.ts";
+import type { ClassId } from "../ast/node/class-id.ts";
+import type { ClassIdRange } from "../ast/node/class-id-range.ts";
+import { ClassIdKind } from "../ast/node/enum/class-id-kind.ts";
+import type { ExtendedClassIdRange } from "../ast/node/extended-class-id-range.ts";
+import { interleaveCommaSeparatorDocs } from "./util/print-utils.ts";
+import { InternalScannerError } from "../scanner-error.ts";
+
+export function printAbstractClassId(
+  path: AstPath<AbstractClassId>,
+  print: (path: AstPath<AbstractNode>) => Doc,
+): Doc {
+  const { classIdKind } = path.node;
+
+  switch (classIdKind) {
+    case ClassIdKind.SINGLE:
+      return (path as AstPath<ClassId>).call(print, "value");
+    case ClassIdKind.RANGE: {
+      return [
+        (path as AstPath<ClassIdRange>).call(print, "startClassId"),
+        (path as AstPath<ClassIdRange>).call(print, "rangeOperator"),
+        (path as AstPath<ClassIdRange>).call(print, "endClassId"),
+      ];
+    }
+    case ClassIdKind.EXTENDED_RANGE: {
+      const doc: Doc = [];
+      const outputValuesDoc = (path as AstPath<ExtendedClassIdRange>).map(
+        print,
+        "classIds",
+      );
+
+      doc.push(
+        interleaveCommaSeparatorDocs(
+          outputValuesDoc,
+          (path as AstPath<ExtendedClassIdRange>).map(
+            print,
+            "commaPunctuators",
+          ),
+        ),
+      );
+
+      return doc;
+    }
+    default: {
+      const exhaustiveCheck: never = classIdKind;
+      throw new InternalScannerError(
+        "Unreachable code reached, classIdKind == " + exhaustiveCheck,
+      );
+    }
+  }
+}

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

@@ -0,0 +1,168 @@
+import { AstPath, type Doc, doc } from "prettier";
+import {
+  addBreakingWhitespace,
+  addNonBreakingWhitespace,
+} from "./util/print-utils.ts";
+import type { AbstractExpression } from "../ast/node/abstract-expression.ts";
+import type { AbstractNode } from "../ast/node/abstract-node.ts";
+import { ExpressionKind } from "../ast/node/enum/expression-kind.ts";
+import type { LengthofExpression } from "../ast/node/length-of-expression.ts";
+import type { BinaryExpression } from "../ast/node/binary-expression.ts";
+import type { UnaryExpression } from "../ast/node/unary-expression.ts";
+import { InternalScannerError } from "../scanner-error.ts";
+
+const { fill } = doc.builders;
+type IfBreak = doc.builders.IfBreak;
+
+function printUnaryExpression(
+  path: AstPath<UnaryExpression>,
+  print: (path: AstPath<AbstractNode>) => Doc,
+): Doc {
+  const unaryExpression = path.node;
+
+  const doc: Doc = [];
+
+  if (unaryExpression.unaryOperator !== undefined) {
+    doc.push(
+      path.call(
+        print,
+        "unaryOperator" as keyof UnaryExpression["unaryOperator"],
+      ),
+    );
+  }
+
+  if (unaryExpression.openParenthesisPunctuator !== undefined) {
+    doc.push(
+      path.call(
+        print,
+        "openParenthesisPunctuator" as keyof UnaryExpression[
+          "openParenthesisPunctuator"
+        ],
+      ),
+    );
+  }
+
+  doc.push(
+    path.call(
+      print,
+      "operand",
+    ),
+  );
+
+  if (unaryExpression.arrayElementAccess !== undefined) {
+    doc.push(
+      ...(
+        path.call(
+          print,
+          "arrayElementAccess" as keyof UnaryExpression["arrayElementAccess"],
+        ) as Doc[]
+      ),
+    );
+  }
+
+  if (unaryExpression.classMemberAccess !== undefined) {
+    doc.push(
+      ...(path.call(
+        print,
+        "classMemberAccess" as keyof UnaryExpression["classMemberAccess"],
+      ) as Doc[]),
+    );
+  }
+
+  if (unaryExpression.closeParenthesisPunctuator !== undefined) {
+    doc.push(
+      path.call(
+        print,
+        "closeParenthesisPunctuator" as keyof UnaryExpression[
+          "closeParenthesisPunctuator"
+        ],
+      ),
+    );
+  }
+
+  if (unaryExpression.postfixOperator !== undefined) {
+    doc.push(
+      path.call(
+        print,
+        "postfixOperator" as keyof UnaryExpression["postfixOperator"],
+      ),
+    );
+  }
+
+  return doc;
+}
+
+function printBinaryExpression(
+  path: AstPath<BinaryExpression>,
+  print: (path: AstPath<AbstractNode>) => Doc,
+): Doc {
+  let subDoc: Doc = [];
+
+  subDoc.push(path.call(print, "leftOperand"));
+  addNonBreakingWhitespace(subDoc);
+  subDoc.push(path.call(print, "binaryOperator"));
+
+  let doc: Doc = [];
+
+  doc.push(fill(subDoc));
+
+  const rightDoc = path.call(print, "rightOperand");
+  if (
+    Array.isArray(rightDoc) && (rightDoc.length === 3) &&
+    ((rightDoc[1] as IfBreak).type === "if-break")
+  ) {
+    subDoc = addBreakingWhitespace(subDoc);
+    subDoc.push(rightDoc[0]);
+    doc.push(rightDoc[1]);
+    doc.push(rightDoc[2]);
+  } else {
+    doc = addBreakingWhitespace(doc);
+    doc.push(rightDoc);
+  }
+
+  return doc;
+}
+
+function printLengthOfExpression(
+  path: AstPath<LengthofExpression>,
+  print: (path: AstPath<AbstractNode>) => Doc,
+): Doc {
+  const doc: Doc = [];
+
+  doc.push(
+    path.call(print, "lengthOfKeyword"),
+  );
+  doc.push(
+    path.call(print, "openParenthesisPunctuator"),
+  );
+  doc.push(path.call(print, "operand"));
+  doc.push(
+    path.call(print, "closeParenthesisPunctuator"),
+  );
+
+  return doc;
+}
+
+export function printAbstractExpression(
+  path: AstPath<AbstractExpression>,
+  print: (path: AstPath<AbstractNode>) => Doc,
+): Doc {
+  const { expressionKind } = path.node;
+  switch (expressionKind) {
+    case ExpressionKind.BINARY:
+      return printBinaryExpression(path as AstPath<BinaryExpression>, print);
+    case ExpressionKind.LENGTHOF:
+      return printLengthOfExpression(
+        path as AstPath<LengthofExpression>,
+        print,
+      );
+    case ExpressionKind.UNARY:
+      return printUnaryExpression(path as AstPath<UnaryExpression>, print);
+    default: {
+      const exhaustiveCheck: never = expressionKind;
+      throw new InternalScannerError(
+        "Unreachable code reached, expressionKind == " + exhaustiveCheck,
+      );
+    }
+  }
+}