@mpeggroup/mpeg-sdl-parser 4.0.0

package/src/ast/build/node/build-for-statement.ts

@@ -0,0 +1,117 @@
+import { InternalScannerError } from "../../../scanner-error.ts";
+import { NodeKind } from "../../node/enum/node-kind.ts";
+import type { AbstractStatement } from "../../node/abstract-statement.ts";
+import type { AbstractExpression } from "../../node/abstract-expression.ts";
+import { ForStatement } from "../../node/for-statement.ts";
+import { ComputedElementaryTypeDefinition } from "../../node/computed-elementary-type-definition.ts";
+import { StatementKind } from "../../node/enum/statement-kind.ts";
+import type { BuildContext } from "../util/build-context.ts";
+import type { AbstractNode } from "../../node/abstract-node.ts";
+import type { Token } from "../../node/token.ts";
+import { fetchOptionalNode, fetchRequiredNode } from "../util/fetch-node.ts";
+import type { OptionalNode } from "../../util/types.ts";
+import { TokenKind } from "../../node/enum/token-kind.ts";
+
+export function buildForStatement(
+  buildContext: BuildContext,
+): ForStatement {
+  const children: Array<AbstractNode> = [];
+
+  const forKeyword = fetchRequiredNode<Token>(
+    buildContext,
+    NodeKind.TOKEN,
+    TokenKind.FOR,
+  );
+  children.push(forKeyword);
+  const openParenthesisPunctuator = fetchRequiredNode<Token>(
+    buildContext,
+    NodeKind.TOKEN,
+    TokenKind.OPEN_PARENTHESIS,
+  );
+  children.push(openParenthesisPunctuator);
+  const expression1 = fetchOptionalNode<AbstractExpression>(
+    buildContext,
+    NodeKind.EXPRESSION,
+  );
+  const semicolon1Punctuator = fetchOptionalNode<Token>(
+    buildContext,
+    NodeKind.TOKEN,
+    TokenKind.SEMICOLON,
+  );
+  let computedElementaryTypeDefinition: OptionalNode<
+    ComputedElementaryTypeDefinition
+  >;
+  if (expression1) {
+    children.push(expression1);
+    if (semicolon1Punctuator) {
+      children.push(semicolon1Punctuator);
+    } else {
+      throw new InternalScannerError(
+        "Expected semicolon after first expression in for statement",
+      );
+    }
+  } else if (semicolon1Punctuator) {
+    children.push(semicolon1Punctuator);
+  } else {
+    computedElementaryTypeDefinition = fetchOptionalNode<
+      ComputedElementaryTypeDefinition
+    >(
+      buildContext,
+      NodeKind.STATEMENT,
+      StatementKind.COMPUTED_ELEMENTARY_TYPE_DEFINITION,
+    );
+    if (computedElementaryTypeDefinition) {
+      children.push(computedElementaryTypeDefinition);
+    } else {
+      throw new InternalScannerError(
+        "Expected either an expression or a computed elementary type definition in for statement",
+      );
+    }
+  }
+
+  const expression2 = fetchOptionalNode<AbstractExpression>(
+    buildContext,
+    NodeKind.EXPRESSION,
+  );
+  if (expression2) {
+    children.push(expression2);
+  }
+  const semicolon2Punctuator = fetchRequiredNode<Token>(
+    buildContext,
+    NodeKind.TOKEN,
+    TokenKind.SEMICOLON,
+  );
+  children.push(semicolon2Punctuator);
+  const expression3 = fetchOptionalNode<AbstractExpression>(
+    buildContext,
+    NodeKind.EXPRESSION,
+  );
+  if (expression3) {
+    children.push(expression3);
+  }
+  const closeParenthesisPunctuator = fetchRequiredNode<Token>(
+    buildContext,
+    NodeKind.TOKEN,
+    TokenKind.CLOSE_PARENTHESIS,
+  );
+  children.push(closeParenthesisPunctuator);
+  const statement = fetchRequiredNode<AbstractStatement>(
+    buildContext,
+    NodeKind.STATEMENT,
+  );
+  children.push(statement);
+
+  return new ForStatement(
+    forKeyword,
+    openParenthesisPunctuator,
+    expression1,
+    computedElementaryTypeDefinition,
+    semicolon1Punctuator,
+    expression2,
+    semicolon2Punctuator,
+    expression3,
+    closeParenthesisPunctuator,
+    statement,
+    children,
+  );
+}

package/src/ast/build/node/build-hexadecimal-literal.ts

@@ -0,0 +1,38 @@
+import { NumberLiteral } from "../../node/number-literal.ts";
+import { NumberLiteralKind } from "../../node/enum/number-literal-kind.ts";
+import { InternalScannerError } from "../../../scanner-error.ts";
+import type { Token } from "../../node/token.ts";
+
+const DOT_SEPARATOR_REGEX = /\./g;
+
+export function buildHexadecimalLiteral(
+  token: Token,
+): NumberLiteral {
+  const literalText = token.text;
+
+  if (!literalText.startsWith("0x")) {
+    throw new InternalScannerError(
+      `Missing hexadecimal literal prefix '0x': ${literalText}`,
+      token.getLocation(),
+    );
+  }
+
+  if (literalText.length === 2) {
+    throw new InternalScannerError(
+      `Missing hexadecimal literal value after prefix '0x'`,
+      token.getLocation(),
+    );
+  }
+
+  const stringValue = literalText.substring(2).trim().replaceAll(
+    DOT_SEPARATOR_REGEX,
+    "",
+  );
+  const value = parseInt(stringValue, 16);
+
+  return new NumberLiteral(
+    NumberLiteralKind.HEXADECIMAL,
+    value,
+    [token],
+  );
+}

package/src/ast/build/node/build-identifier.ts

@@ -0,0 +1,8 @@
+import { Identifier } from "../../node/identifier.ts";
+import type { Token } from "../../node/token.ts";
+
+export function buildIdentifier(
+  token: Token,
+): Identifier {
+  return new Identifier(token.text, token);
+}

package/src/ast/build/node/build-if-statement.ts

@@ -0,0 +1,82 @@
+import { InternalScannerError } from "../../../scanner-error.ts";
+import { NodeKind } from "../../node/enum/node-kind.ts";
+import { IfStatement } from "../../node/if-statement.ts";
+import type { AbstractStatement } from "../../node/abstract-statement.ts";
+import type { AbstractExpression } from "../../node/abstract-expression.ts";
+import type { NumberLiteral } from "../../node/number-literal.ts";
+import type { Identifier } from "../../node/identifier.ts";
+import type { BuildContext } from "../util/build-context.ts";
+import type { AbstractNode } from "../../node/abstract-node.ts";
+import { fetchOptionalNode, fetchRequiredNode } from "../util/fetch-node.ts";
+import type { OptionalNode } from "../../util/types.ts";
+import type { Token } from "../../node/token.ts";
+import { TokenKind } from "../../node/enum/token-kind.ts";
+
+export function buildIfStatement(
+  buildContext: BuildContext,
+): IfStatement {
+  const children: Array<AbstractNode> = [];
+
+  const ifKeyword = fetchRequiredNode<Token>(
+    buildContext,
+    NodeKind.TOKEN,
+    TokenKind.IF,
+  );
+  children.push(ifKeyword);
+  const openParenthesisPunctuator = fetchRequiredNode<Token>(
+    buildContext,
+    NodeKind.TOKEN,
+    TokenKind.OPEN_PARENTHESIS,
+  );
+  children.push(openParenthesisPunctuator);
+  const condition = fetchRequiredNode<
+    AbstractExpression | NumberLiteral | Identifier
+  >(
+    buildContext,
+    [NodeKind.EXPRESSION, NodeKind.IDENTIFIER, NodeKind.NUMBER_LITERAL],
+  );
+  children.push(condition);
+  const closeParenthesisPunctuator = fetchRequiredNode<Token>(
+    buildContext,
+    NodeKind.TOKEN,
+    TokenKind.CLOSE_PARENTHESIS,
+  );
+  children.push(closeParenthesisPunctuator);
+  const ifStatement = fetchRequiredNode<AbstractStatement>(
+    buildContext,
+    NodeKind.STATEMENT,
+  );
+  children.push(ifStatement);
+  const elseKeyword = fetchOptionalNode<Token>(
+    buildContext,
+    NodeKind.TOKEN,
+    TokenKind.ELSE,
+  );
+  let elseStatement: OptionalNode<AbstractStatement> = undefined;
+  if (elseKeyword) {
+    children.push(elseKeyword);
+    elseStatement = fetchOptionalNode<AbstractStatement>(
+      buildContext,
+      NodeKind.STATEMENT,
+    );
+    if (elseStatement) {
+      children.push(elseStatement);
+    } else {
+      throw new InternalScannerError(
+        "Expected else statement after else keyword",
+        (elseKeyword as Token).getLocation(),
+      );
+    }
+  }
+
+  return new IfStatement(
+    ifKeyword,
+    openParenthesisPunctuator,
+    condition,
+    closeParenthesisPunctuator,
+    ifStatement,
+    elseKeyword,
+    elseStatement,
+    children,
+  );
+}

package/src/ast/build/node/build-implicit-array-dimension.ts

@@ -0,0 +1,78 @@
+import { InternalScannerError } from "../../../scanner-error.ts";
+import { NodeKind } from "../../node/enum/node-kind.ts";
+import type { Identifier } from "../../node/identifier.ts";
+import { ImplicitArrayDimension } from "../../node/implicit-array-dimension.ts";
+import type { AbstractExpression } from "../../node/abstract-expression.ts";
+import type { NumberLiteral } from "../../node/number-literal.ts";
+import type { BuildContext } from "../util/build-context.ts";
+import type { AbstractNode } from "../../node/abstract-node.ts";
+import type { Token } from "../../node/token.ts";
+import { fetchOptionalNode, fetchRequiredNode } from "../util/fetch-node.ts";
+import type { OptionalNode } from "../../util/types.ts";
+import { TokenKind } from "../../node/enum/token-kind.ts";
+
+export function buildImplicitArrayDimension(
+  buildContext: BuildContext,
+): ImplicitArrayDimension {
+  const children: Array<AbstractNode> = [];
+
+  const openBracketPunctuator = fetchRequiredNode<Token>(
+    buildContext,
+    NodeKind.TOKEN,
+    TokenKind.OPEN_BRACKET,
+  );
+  children.push(openBracketPunctuator);
+  const rangeStart = fetchOptionalNode<
+    AbstractExpression | NumberLiteral | Identifier
+  >(
+    buildContext,
+    [NodeKind.EXPRESSION, NodeKind.IDENTIFIER, NodeKind.NUMBER_LITERAL],
+  );
+  let rangeOperator: OptionalNode<Token> = undefined;
+  let rangeEnd: OptionalNode<
+    AbstractExpression | NumberLiteral | Identifier
+  > = undefined;
+  if (rangeStart) {
+    children.push(rangeStart);
+    rangeOperator = fetchOptionalNode<Token>(
+      buildContext,
+      NodeKind.TOKEN,
+      TokenKind.RANGE_OPERATOR,
+    );
+    if (rangeOperator) {
+      children.push(rangeOperator);
+    } else {
+      throw new InternalScannerError(
+        "Expected range operator after range start in implicit array dimension",
+      );
+    }
+    rangeEnd = fetchOptionalNode<
+      AbstractExpression | NumberLiteral | Identifier
+    >(
+      buildContext,
+      [NodeKind.EXPRESSION, NodeKind.IDENTIFIER, NodeKind.NUMBER_LITERAL],
+    );
+    if (rangeEnd) {
+      children.push(rangeEnd);
+    } else {
+      throw new InternalScannerError(
+        "Expected range end after range operator in implicit array dimension",
+      );
+    }
+  }
+  const closeBracketPunctuator = fetchRequiredNode<Token>(
+    buildContext,
+    NodeKind.TOKEN,
+    TokenKind.CLOSE_BRACKET,
+  );
+  children.push(closeBracketPunctuator);
+
+  return new ImplicitArrayDimension(
+    openBracketPunctuator,
+    rangeStart,
+    rangeOperator,
+    rangeEnd,
+    closeBracketPunctuator,
+    children,
+  );
+}

package/src/ast/build/node/build-integer-literal.ts

@@ -0,0 +1,15 @@
+import { NumberLiteral } from "../../node/number-literal.ts";
+import { NumberLiteralKind } from "../../node/enum/number-literal-kind.ts";
+import type { Token } from "../../node/token.ts";
+
+export function buildIntegerLiteral(
+  token: Token,
+): NumberLiteral {
+  const value = parseInt(token.text, 10);
+
+  return new NumberLiteral(
+    NumberLiteralKind.INTEGER,
+    value,
+    [token],
+  );
+}

package/src/ast/build/node/build-length-attribute.ts

@@ -0,0 +1,48 @@
+import type { AbstractExpression } from "../../../../index.ts";
+import type { AbstractNode } from "../../node/abstract-node.ts";
+import { NodeKind } from "../../node/enum/node-kind.ts";
+import { TokenKind } from "../../node/enum/token-kind.ts";
+import type { Identifier } from "../../node/identifier.ts";
+import { LengthAttribute } from "../../node/length-attribute.ts";
+import type { NumberLiteral } from "../../node/number-literal.ts";
+import type { Token } from "../../node/token.ts";
+import { fetchRequiredNode } from "../util/fetch-node.ts";
+import type { BuildContext } from "../util/build-context.ts";
+
+export function buildLengthAttribute(
+  buildContext: BuildContext,
+): LengthAttribute {
+  const children: Array<AbstractNode> = [];
+
+  const openParenthesisPunctuator = fetchRequiredNode<Token>(
+    buildContext,
+    NodeKind.TOKEN,
+    TokenKind.OPEN_PARENTHESIS,
+  );
+
+  children.push(openParenthesisPunctuator);
+
+  const length = fetchRequiredNode<
+    NumberLiteral | Identifier | AbstractExpression
+  >(
+    buildContext,
+    [NodeKind.EXPRESSION, NodeKind.IDENTIFIER, NodeKind.NUMBER_LITERAL],
+  );
+
+  children.push(length);
+
+  const closeParenthesisPunctuator = fetchRequiredNode<Token>(
+    buildContext,
+    NodeKind.TOKEN,
+    TokenKind.CLOSE_PARENTHESIS,
+  );
+
+  children.push(closeParenthesisPunctuator);
+
+  return new LengthAttribute(
+    openParenthesisPunctuator,
+    length,
+    closeParenthesisPunctuator,
+    children,
+  );
+}

package/src/ast/build/node/build-lengthof-expression.ts

@@ -0,0 +1,45 @@
+import type { AbstractExpression } from "../../node/abstract-expression.ts";
+import { NodeKind } from "../../node/enum/node-kind.ts";
+import type { Identifier } from "../../node/identifier.ts";
+import { LengthofExpression } from "../../node/length-of-expression.ts";
+import type { BuildContext } from "../util/build-context.ts";
+import type { Token } from "../../node/token.ts";
+import { fetchRequiredNode } from "../util/fetch-node.ts";
+import { TokenKind } from "../../node/enum/token-kind.ts";
+
+export function buildLengthofExpression(
+  buildContext: BuildContext,
+): LengthofExpression {
+  const lengthOfKeyword = fetchRequiredNode<Token>(
+    buildContext,
+    NodeKind.TOKEN,
+    TokenKind.LENGTHOF,
+  );
+  const openParenthesisPunctuator = fetchRequiredNode<Token>(
+    buildContext,
+    NodeKind.TOKEN,
+    TokenKind.OPEN_PARENTHESIS,
+  );
+  const operand = fetchRequiredNode<AbstractExpression | Identifier>(
+    buildContext,
+    [NodeKind.EXPRESSION, NodeKind.IDENTIFIER],
+  );
+  const closedParenthesisPunctuator = fetchRequiredNode<Token>(
+    buildContext,
+    NodeKind.TOKEN,
+    TokenKind.CLOSE_PARENTHESIS,
+  );
+
+  return new LengthofExpression(
+    lengthOfKeyword,
+    openParenthesisPunctuator,
+    operand,
+    closedParenthesisPunctuator,
+    [
+      lengthOfKeyword,
+      openParenthesisPunctuator,
+      operand,
+      closedParenthesisPunctuator,
+    ],
+  );
+}

package/src/ast/build/node/build-map-declaration.ts

@@ -0,0 +1,110 @@
+import { InternalScannerError } from "../../../scanner-error.ts";
+import { NodeKind } from "../../node/enum/node-kind.ts";
+import type { Identifier } from "../../node/identifier.ts";
+import { MapDeclaration } from "../../node/map-declaration.ts";
+import type { ElementaryType } from "../../node/elementary-type.ts";
+import type { MapEntry } from "../../node/map-entry.ts";
+import type { BuildContext } from "../util/build-context.ts";
+import type { AbstractNode } from "../../node/abstract-node.ts";
+import type { Token } from "../../node/token.ts";
+import {
+  fetchOneToManyCommaSeparatedList,
+  fetchOptionalNode,
+  fetchRequiredNode,
+} from "../util/fetch-node.ts";
+import type { OptionalNode } from "../../util/types.ts";
+import { TokenKind } from "../../node/enum/token-kind.ts";
+
+export function buildMapDeclaration(
+  buildContext: BuildContext,
+): MapDeclaration {
+  const children: Array<AbstractNode> = [];
+
+  const mapKeyword = fetchRequiredNode<Token>(
+    buildContext,
+    NodeKind.TOKEN,
+    TokenKind.MAP,
+  );
+  children.push(mapKeyword);
+  const identifier = fetchRequiredNode<Identifier>(
+    buildContext,
+    NodeKind.IDENTIFIER,
+  );
+  children.push(identifier);
+
+  const openParenthesisPunctuator = fetchRequiredNode<Token>(
+    buildContext,
+    NodeKind.TOKEN,
+    TokenKind.OPEN_PARENTHESIS,
+  );
+  children.push(openParenthesisPunctuator);
+
+  const outputElementaryType = fetchOptionalNode<ElementaryType>(
+    buildContext,
+    NodeKind.ELEMENTARY_TYPE,
+  );
+  let outputClassIdentifier: OptionalNode<Identifier> = undefined;
+  if (outputElementaryType) {
+    children.push(outputElementaryType);
+  } else {
+    outputClassIdentifier = fetchOptionalNode<Identifier>(
+      buildContext,
+      NodeKind.IDENTIFIER,
+    );
+    if (outputClassIdentifier) {
+      children.push(outputClassIdentifier);
+    } else {
+      throw new InternalScannerError(
+        "MapDeclaration must have either an output elementary type or an output class identifier.",
+      );
+    }
+  }
+
+  const closeParenthesisPunctuator = fetchRequiredNode<Token>(
+    buildContext,
+    NodeKind.TOKEN,
+    TokenKind.CLOSE_PARENTHESIS,
+  );
+  children.push(closeParenthesisPunctuator);
+
+  const openBracePunctuator = fetchRequiredNode<Token>(
+    buildContext,
+    NodeKind.TOKEN,
+    TokenKind.OPEN_BRACE,
+  );
+  children.push(openBracePunctuator);
+  const { nodes: mapEntries, commaPunctuators } =
+    fetchOneToManyCommaSeparatedList<MapEntry>(
+      buildContext,
+      NodeKind.MAP_ENTRY,
+    );
+
+  // now push each output value and comma punctuator to children
+  for (let i = 0; i < mapEntries.length; i++) {
+    children.push(mapEntries[i]);
+    if (i < commaPunctuators.length) {
+      children.push(commaPunctuators[i]);
+    }
+  }
+
+  const closeBracePunctuator = fetchRequiredNode<Token>(
+    buildContext,
+    NodeKind.TOKEN,
+    TokenKind.CLOSE_BRACE,
+  );
+  children.push(closeBracePunctuator);
+
+  return new MapDeclaration(
+    mapKeyword,
+    identifier,
+    openParenthesisPunctuator,
+    outputElementaryType,
+    outputClassIdentifier,
+    closeParenthesisPunctuator,
+    openBracePunctuator,
+    mapEntries,
+    commaPunctuators,
+    closeBracePunctuator,
+    children,
+  );
+}

package/src/ast/build/node/build-map-definition.ts

@@ -0,0 +1,103 @@
+import { Identifier } from "../../node/identifier.ts";
+import type { BuildContext } from "../util/build-context.ts";
+import type { AbstractNode } from "../../node/abstract-node.ts";
+import { MapDefinition } from "../../node/map-definition.ts";
+import { fetchOptionalNode, fetchRequiredNode } from "../util/fetch-node.ts";
+import type { Token } from "../../node/token.ts";
+import { NodeKind } from "../../node/enum/node-kind.ts";
+import { TokenKind } from "../../node/enum/token-kind.ts";
+import type { OptionalNode } from "../../util/types.ts";
+import { InternalScannerError } from "../../../scanner-error.ts";
+import type { ElementaryType } from "../../node/elementary-type.ts";
+
+export function buildMapDefinition(
+  buildContext: BuildContext,
+): MapDefinition {
+  const children: Array<AbstractNode> = [];
+
+  const reservedKeyword = fetchOptionalNode<Token>(
+    buildContext,
+    NodeKind.TOKEN,
+    TokenKind.RESERVED,
+  );
+  if (reservedKeyword) {
+    children.push(reservedKeyword);
+  }
+
+  const legacyKeyword = fetchOptionalNode<Token>(
+    buildContext,
+    NodeKind.TOKEN,
+    TokenKind.LEGACY,
+  );
+  if (legacyKeyword) {
+    children.push(legacyKeyword);
+  }
+
+  const elementaryType = fetchOptionalNode<ElementaryType>(
+    buildContext,
+    NodeKind.ELEMENTARY_TYPE,
+  );
+  let classIdentifier: OptionalNode<Identifier> | undefined;
+
+  if (elementaryType) {
+    children.push(elementaryType);
+  } else {
+    classIdentifier = fetchOptionalNode<Identifier>(
+      buildContext,
+      NodeKind.IDENTIFIER,
+    );
+    if (classIdentifier) {
+      children.push(classIdentifier);
+    } else {
+      throw new InternalScannerError(
+        "Expected either an elementary type or a class identifier in map definition",
+      );
+    }
+  }
+
+  const relationalLessThanPunctuator = fetchRequiredNode<Token>(
+    buildContext,
+    NodeKind.TOKEN,
+    TokenKind.RELATIONAL_LESS_THAN,
+  );
+  children.push(relationalLessThanPunctuator);
+
+  const mapIdentifier = fetchRequiredNode<Identifier>(
+    buildContext,
+    NodeKind.IDENTIFIER,
+  );
+  children.push(mapIdentifier);
+
+  const relationalGreaterThanPunctuator = fetchRequiredNode<Token>(
+    buildContext,
+    NodeKind.TOKEN,
+    TokenKind.RELATIONAL_GREATER_THAN,
+  );
+  children.push(relationalGreaterThanPunctuator);
+
+  const identifier = fetchRequiredNode<Identifier>(
+    buildContext,
+    NodeKind.IDENTIFIER,
+  );
+  children.push(identifier);
+
+  const semicolonPunctuator = fetchRequiredNode<Token>(
+    buildContext,
+    NodeKind.TOKEN,
+    TokenKind.SEMICOLON,
+  );
+  children.push(semicolonPunctuator);
+
+  return new MapDefinition(
+    reservedKeyword,
+    legacyKeyword,
+    elementaryType,
+    classIdentifier,
+    relationalLessThanPunctuator,
+    mapIdentifier,
+    relationalGreaterThanPunctuator,
+    identifier,
+    semicolonPunctuator,
+    children,
+  );
+}

package/src/ast/build/node/build-map-entry.ts

@@ -0,0 +1,33 @@
+import { NodeKind } from "../../node/enum/node-kind.ts";
+import { MapEntry } from "../../node/map-entry.ts";
+import type { NumberLiteral } from "../../node/number-literal.ts";
+import type { AggregateOutputValue } from "../../node/aggregate-output-value.ts";
+import type { BuildContext } from "../util/build-context.ts";
+import type { Token } from "../../node/token.ts";
+import { fetchRequiredNode } from "../util/fetch-node.ts";
+import { TokenKind } from "../../node/enum/token-kind.ts";
+
+export function buildMapEntry(
+  buildContext: BuildContext,
+): MapEntry {
+  const inputValue = fetchRequiredNode<NumberLiteral>(
+    buildContext,
+    NodeKind.NUMBER_LITERAL,
+  );
+  const commaPunctuator = fetchRequiredNode<Token>(
+    buildContext,
+    NodeKind.TOKEN,
+    TokenKind.COMMA,
+  );
+  const outputValue = fetchRequiredNode<AggregateOutputValue>(
+    buildContext,
+    NodeKind.AGGREGATE_OUTPUT_VALUE,
+  );
+
+  return new MapEntry(
+    inputValue,
+    commaPunctuator,
+    outputValue,
+    [inputValue, commaPunctuator, outputValue],
+  );
+}

package/src/ast/build/node/build-missing-error.ts

@@ -0,0 +1,10 @@
+import { getLocationFromTextPosition } from "../../../util/location-utils.ts";
+import type { BuildContext } from "../util/build-context.ts";
+import { MissingError } from "../../node/missing-error.ts";
+
+export function buildMissingError(buildContext: BuildContext): MissingError {
+  const { cursor, text } = buildContext;
+  const location = getLocationFromTextPosition(text, cursor.from);
+
+  return new MissingError(location);
+}