@mpeggroup/mpeg-sdl-parser 4.1.1 → 4.1.3

package/dist/src/ast/build/consume/consume-abstract-node.js

@@ -0,0 +1,160 @@
+import { createSyntaxErrorFromTextAndCursor } from "../../../lezer/create-syntax-error-from-text-and-cursor.js";
+import { primitiveNodeProp } from "../../../lezer/props/primitive-node-prop-source.js";
+import { buildToken } from "../node/build-token.js";
+import { consumeTrivia } from "./consume-trivia.js";
+import { InternalScannerError } from "../../../scanner-error.js";
+import getLogger from "../../../util/logger.js";
+import { buildMissingError } from "../node/build-missing-error.js";
+import { consumePrimitive } from "./consume-primitive.js";
+import { consumeAstNode } from "./consume-ast-node.js";
+import { Specification } from "../../node/specification.js";
+import { NodeKind } from "../../node/enum/node-kind.js";
+import { tokenKindByTokenTypeId } from "../util/token-kind-by-token-type-id-map.js";
+import { nodeKindByTokenTypeId } from "../util/node-kind-by-token-type-id-map.js";
+import { UnexpectedError } from "../../node/unexpected-error.js";
+const logger = getLogger("consumeAbstractNode");
+export var NodeScenario;
+(function (NodeScenario) {
+    /** Missing Error Node */
+    NodeScenario[NodeScenario["MISSING_NODE"] = 0] = "MISSING_NODE";
+    /** Unexpected Error Node containing a child which is the unexpected token */
+    NodeScenario[NodeScenario["UNEXPECTED_NODE"] = 1] = "UNEXPECTED_NODE";
+    /** Unknown Error Node which has text of an unknown token */
+    NodeScenario[NodeScenario["UNKNOWN_TOKEN"] = 2] = "UNKNOWN_TOKEN";
+    /** Primitive Node e.g. Identifier, IntegerLiteral... */
+    NodeScenario[NodeScenario["PRIMITIVE"] = 3] = "PRIMITIVE";
+    /** Terminal Token Node e.g. class, int... */
+    NodeScenario[NodeScenario["TOKEN"] = 4] = "TOKEN";
+    /** Non-Terminal AST Node e.g. ClassDeclaration, ExpressionStatement... */
+    NodeScenario[NodeScenario["AST_NODE"] = 5] = "AST_NODE";
+    /** Terminal AST Node with missing children e.g. ClassDeclaration, ExpressionStatement... */
+    NodeScenario[NodeScenario["EMPTY_AST_NODE"] = 6] = "EMPTY_AST_NODE";
+})(NodeScenario || (NodeScenario = {}));
+function determineNodeScenario(buildContext) {
+    const { cursor, text, lenient } = buildContext;
+    const isError = cursor.type.isError;
+    if (isError && !lenient) {
+        throw createSyntaxErrorFromTextAndCursor(text, cursor);
+    }
+    // Check if current sytax node is a terminal token by attempting to move to first child
+    const childExists = cursor.firstChild();
+    if (isError) {
+        // If the cursor was an error and it has a child, it is an unexpected token error
+        // In this case the child is the unexpected token, we can treat it like an AST node
+        // so move back to parent
+        if (childExists) {
+            cursor.parent();
+            return NodeScenario.UNEXPECTED_NODE;
+        }
+        // If it is an error and no child exists, check if there is text, if so treat this as an
+        // unknown token error.
+        if (cursor.to > cursor.from) {
+            return NodeScenario.UNKNOWN_TOKEN;
+        }
+        // Otherwise it is a missing node error.
+        return NodeScenario.MISSING_NODE;
+    }
+    // If we have a child, we should not use it yet, so move back to parent
+    if (childExists) {
+        cursor.parent();
+    }
+    // Primitive is a terminal custom text rather than a syntax token, this will be treated slightly differently
+    if (cursor.type.prop(primitiveNodeProp)) {
+        return NodeScenario.PRIMITIVE;
+    }
+    // Check if it is a token type
+    if (tokenKindByTokenTypeId.get(cursor.type.id) !== undefined) {
+        return NodeScenario.TOKEN;
+    }
+    // If it has no children, it is an empty AST node
+    if (!childExists) {
+        return NodeScenario.EMPTY_AST_NODE;
+    }
+    // Otherwise it is a non-terminal AST node
+    return NodeScenario.AST_NODE;
+}
+/*
+ * Iterate through the syntax tree and consume parse tree tokens to create an AST node.
+ */
+export function consumeAbstractNode(buildContext) {
+    const { cursor } = buildContext;
+    const currentState = buildContext.stateStack[buildContext.stateStack.length - 1];
+    // Get any leading trivia for the node
+    const leadingTrivia = consumeTrivia(buildContext, false);
+    // If no siblings remain to be consumed, return undefined
+    if (currentState.isEndOfSiblings) {
+        if (leadingTrivia.length > 0) {
+            if (buildContext.unconsumedTrivia) {
+                throw new InternalScannerError(`Expected no unconsumed trivia, but found some.`);
+            }
+            buildContext.unconsumedTrivia = leadingTrivia;
+        }
+        return undefined;
+    }
+    // Determine what kind of node we are about to consume
+    const nodeScenario = determineNodeScenario(buildContext);
+    logger.debug(currentState.indent +
+        "consuming node: " +
+        cursor.name +
+        ` (scenario: ${NodeScenario[nodeScenario]})`);
+    let node;
+    switch (nodeScenario) {
+        case NodeScenario.MISSING_NODE:
+            node = buildMissingError(buildContext);
+            break;
+        case NodeScenario.PRIMITIVE:
+            node = consumePrimitive(buildContext);
+            break;
+        case NodeScenario.UNKNOWN_TOKEN: {
+            const unknownToken = buildToken(buildContext);
+            // wrap unknown token in unexpected node
+            node = new UnexpectedError(unknownToken);
+            break;
+        }
+        case NodeScenario.TOKEN:
+            node = buildToken(buildContext);
+            break;
+        case NodeScenario.UNEXPECTED_NODE:
+        case NodeScenario.AST_NODE:
+            node = consumeAstNode(buildContext);
+            break;
+        case NodeScenario.EMPTY_AST_NODE: {
+            const nodeKind = nodeKindByTokenTypeId.get(cursor.type.id);
+            if (nodeKind === undefined) {
+                throw new InternalScannerError(`No nodeKind mapping found for token type id: ${cursor.type.id} (${cursor.type.name})`);
+            }
+            // Allow specification to have no children
+            if (nodeKind == NodeKind.SPECIFICATION) {
+                return new Specification([]);
+            }
+            else {
+                throw new InternalScannerError(`Expected node to have at least one child: ${NodeKind[nodeKind]}`);
+            }
+        }
+        default: {
+            const exhaustiveCheck = nodeScenario;
+            throw new InternalScannerError("Unreachable code reached, nodeScenario == " + exhaustiveCheck);
+        }
+    }
+    // Set any leading trivia now we have the node
+    if (leadingTrivia.length > 0) {
+        node.leadingTrivia = leadingTrivia;
+    }
+    // Now that we have consumed a node, move to next sibling
+    if (cursor.nextSibling()) {
+        currentState.isEndOfSiblings = false;
+    }
+    else {
+        currentState.isEndOfSiblings = true;
+    }
+    // Get any trailing trivia for the node
+    const trailingTrivia = consumeTrivia(buildContext, true);
+    if (trailingTrivia.length > 0) {
+        node.trailingTrivia = trailingTrivia;
+    }
+    logger.debug(currentState.indent +
+        "current node: " +
+        cursor.name +
+        (currentState.isEndOfSiblings ? ": end of siblings" : ""));
+    return node;
+}

package/dist/src/ast/build/consume/consume-ast-node.d.ts

@@ -0,0 +1,4 @@
+import type { AbstractNode } from "../../node/abstract-node.ts";
+import type { BuildContext } from "../util/build-context.ts";
+export declare function consumeAstNode(buildContext: BuildContext): AbstractNode;
+//# sourceMappingURL=consume-ast-node.d.ts.map

package/dist/src/ast/build/consume/consume-ast-node.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"consume-ast-node.d.ts","sourceRoot":"","sources":["../../../../../src/ast/build/consume/consume-ast-node.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAgDhE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAoL7D,wBAAgB,cAAc,CAAC,YAAY,EAAE,YAAY,GAAG,YAAY,CA8IvE"}

package/dist/src/ast/build/consume/consume-ast-node.js

@@ -0,0 +1,297 @@
+import getLogger from "../../../util/logger.js";
+import { buildAggregateOutputValue } from "../node/build-aggregate-output-value.js";
+import { buildAlignedModifier } from "../node/build-aligned-modifier.js";
+import { buildArrayDefinition } from "../node/build-array-definition.js";
+import { buildArrayElementAccess } from "../node/build-array-element-access.js";
+import { buildBase64StringLiteral } from "../node/build-base64-string-literal.js";
+import { buildBinaryExpression } from "../node/build-binary-expression.js";
+import { buildBitModifier } from "../node/build-bit-modifier.js";
+import { buildCaseClause } from "../node/build-case-clause.js";
+import { buildClassDeclaration } from "../node/build-class-declaration.js";
+import { buildClassDefinition } from "../node/build-class-definition.js";
+import { buildClassIdRange } from "../node/build-class-id-range.js";
+import { buildClassId } from "../node/build-class-id.js";
+import { buildClassMemberAccess } from "../node/build-class-member-access.js";
+import { buildCompoundStatement } from "../node/build-compound-statement.js";
+import { buildComputedArrayDefinition } from "../node/build-computed-array-definition.js";
+import { buildComputedElementaryTypeDefinition } from "../node/build-computed-elementary-type-definition.js";
+import { buildDefaultClause } from "../node/build-default-clause.js";
+import { buildDoStatement } from "../node/build-do-statement.js";
+import { buildElementaryTypeDefinition } from "../node/build-elementary-type-definition.js";
+import { buildElementaryTypeOutputValue } from "../node/build-elementary-type-output-value.js";
+import { buildElementaryType } from "../node/build-elementary-type.js";
+import { buildExpandableModifier } from "../node/build-expandable-modifier.js";
+import { buildExplicitArrayDimension } from "../node/build-explicit-array-dimension.js";
+import { buildExpressionStatement } from "../node/build-expression-statement.js";
+import { buildExtendedClassIdRange } from "../node/build-extended-class-id-range.js";
+import { buildExtendsModifier } from "../node/build-extends-modifier.js";
+import { buildForStatement } from "../node/build-for-statement.js";
+import { buildIfStatement } from "../node/build-if-statement.js";
+import { buildImplicitArrayDimension } from "../node/build-implicit-array-dimension.js";
+import { buildLengthAttribute } from "../node/build-length-attribute.js";
+import { buildLengthofExpression } from "../node/build-lengthof-expression.js";
+import { buildMapDeclaration } from "../node/build-map-declaration.js";
+import { buildMapEntry } from "../node/build-map-entry.js";
+import { buildMultipleCharacterLiteral } from "../node/build-multiple-character-literal.js";
+import { buildParameterList } from "../node/build-parameter-list.js";
+import { buildParameterValueList } from "../node/build-parameter-value-list.js";
+import { buildParameter } from "../node/build-parameter.js";
+import { buildPartialArrayDimension } from "../node/build-partial-array-dimension.js";
+import { buildSpecification } from "../node/build-specification.js";
+import { buildStringDefinition } from "../node/build-string-definition.js";
+import { buildSwitchStatement } from "../node/build-switch-statement.js";
+import { buildUnaryExpression } from "../node/build-unary-expression.js";
+import { buildUtfStringLiteral } from "../node/build-utf-string-literal.js";
+import { buildWhileStatement } from "../node/build-while-statement.js";
+import { InternalScannerError } from "../../../scanner-error.js";
+import { NodeKind } from "../../node/enum/node-kind.js";
+import { buildUnexpectedError } from "../node/build-unexpected-error.js";
+import { nodeKindByTokenTypeId } from "../util/node-kind-by-token-type-id-map.js";
+import { ArrayDimensionKind } from "../../node/enum/array-dimension-kind.js";
+import { arrayDimensionKindByTokenTypeId } from "../util/array-dimension-kind-by-token-type-id-map.js";
+import { stringLiteralKindByTokenTypeId } from "../util/string-literal-kind-by-token-type-id-map.js";
+import { statementKindByTokenTypeId } from "../util/statement-kind-by-token-type-id-map.js";
+import { expressionKindByTokenTypeId } from "../util/expression-kind-by-token-type-id-map.js";
+import { classIdKindByTokenTypeId } from "../util/class-id-kind-by-token-type-id-map.js";
+import { ClassIdKind } from "../../node/enum/class-id-kind.js";
+import { ExpressionKind } from "../../node/enum/expression-kind.js";
+import { StatementKind } from "../../node/enum/statement-kind.js";
+import { buildMapDefinition } from "../node/build-map-definition.js";
+import { StringLiteralKind } from "../../node/enum/string-literal-kind.js";
+import { consumeWhiteSpaceAndMissingErrors } from "./consume-white-space-and-missing-errors.js";
+const logger = getLogger("consumeAstNode");
+function consumeArrayDimension(buildContext, parentTypeId, parentTypeName) {
+    const arrayDimensionKind = arrayDimensionKindByTokenTypeId.get(parentTypeId);
+    if (arrayDimensionKind === undefined) {
+        throw new InternalScannerError(`No arrayDimensionKind mapping found for token type id: ${parentTypeId} (${parentTypeName})`);
+    }
+    switch (arrayDimensionKind) {
+        case ArrayDimensionKind.EXPLICIT:
+            return buildExplicitArrayDimension(buildContext);
+        case ArrayDimensionKind.IMPLICIT:
+            return buildImplicitArrayDimension(buildContext);
+        case ArrayDimensionKind.PARTIAL:
+            return buildPartialArrayDimension(buildContext);
+        default: {
+            const exhaustiveCheck = arrayDimensionKind;
+            throw new InternalScannerError("Unreachable code reached, arrayDimensionKind == " + exhaustiveCheck);
+        }
+    }
+}
+function consumeClassId(buildContext, parentTypeId, parentTypeName) {
+    const classIdKind = classIdKindByTokenTypeId.get(parentTypeId);
+    if (classIdKind === undefined) {
+        throw new InternalScannerError(`No classIdKind mapping found for token type id: ${parentTypeId} (${parentTypeName})`);
+    }
+    switch (classIdKind) {
+        case ClassIdKind.SINGLE:
+            return buildClassId(buildContext);
+        case ClassIdKind.RANGE:
+            return buildClassIdRange(buildContext);
+        case ClassIdKind.EXTENDED_RANGE:
+            return buildExtendedClassIdRange(buildContext);
+        default: {
+            const exhaustiveCheck = classIdKind;
+            throw new InternalScannerError("Unreachable code reached, classIdKind == " + exhaustiveCheck);
+        }
+    }
+}
+function consumeExpression(buildContext, parentTypeId, parentTypeName) {
+    const expressionKind = expressionKindByTokenTypeId.get(parentTypeId);
+    if (expressionKind === undefined) {
+        throw new InternalScannerError(`No expressionKind mapping found for token type id: ${parentTypeId} (${parentTypeName})`);
+    }
+    switch (expressionKind) {
+        case ExpressionKind.BINARY:
+            return buildBinaryExpression(buildContext);
+        case ExpressionKind.UNARY:
+            return buildUnaryExpression(buildContext);
+        case ExpressionKind.LENGTHOF:
+            return buildLengthofExpression(buildContext);
+        default: {
+            const exhaustiveCheck = expressionKind;
+            throw new InternalScannerError("Unreachable code reached, expressionKind == " + exhaustiveCheck);
+        }
+    }
+}
+function consumeStatement(buildContext, parentTypeId, parentTypeName) {
+    const statementKind = statementKindByTokenTypeId.get(parentTypeId);
+    if (statementKind === undefined) {
+        throw new InternalScannerError(`No statementKind mapping found for token type id: ${parentTypeId} (${parentTypeName})`);
+    }
+    switch (statementKind) {
+        case StatementKind.ARRAY_DEFINITION:
+            return buildArrayDefinition(buildContext);
+        case StatementKind.CLASS_DECLARATION:
+            return buildClassDeclaration(buildContext);
+        case StatementKind.CLASS_DEFINITION:
+            return buildClassDefinition(buildContext);
+        case StatementKind.COMPOUND:
+            return buildCompoundStatement(buildContext);
+        case StatementKind.COMPUTED_ARRAY_DEFINITION:
+            return buildComputedArrayDefinition(buildContext);
+        case StatementKind.COMPUTED_ELEMENTARY_TYPE_DEFINITION:
+            return buildComputedElementaryTypeDefinition(buildContext);
+        case StatementKind.DO:
+            return buildDoStatement(buildContext);
+        case StatementKind.ELEMENTARY_TYPE_DEFINITION:
+            return buildElementaryTypeDefinition(buildContext);
+        case StatementKind.EXPRESSION:
+            return buildExpressionStatement(buildContext);
+        case StatementKind.FOR:
+            return buildForStatement(buildContext);
+        case StatementKind.IF:
+            return buildIfStatement(buildContext);
+        case StatementKind.MAP_DECLARATION:
+            return buildMapDeclaration(buildContext);
+        case StatementKind.MAP_DEFINITION:
+            return buildMapDefinition(buildContext);
+        case StatementKind.STRING_DEFINITION:
+            return buildStringDefinition(buildContext);
+        case StatementKind.SWITCH:
+            return buildSwitchStatement(buildContext);
+        case StatementKind.WHILE:
+            return buildWhileStatement(buildContext);
+        default: {
+            const exhaustiveCheck = statementKind;
+            throw new InternalScannerError("Unreachable code reached, statementKind == " + exhaustiveCheck);
+        }
+    }
+}
+function consumeStringLiteral(buildContext, parentTypeId, parentTypeName) {
+    const stringLiteralKind = stringLiteralKindByTokenTypeId.get(parentTypeId);
+    if (stringLiteralKind === undefined) {
+        throw new InternalScannerError(`No stringLiteralKind mapping found for token type id: ${parentTypeId} (${parentTypeName})`);
+    }
+    switch (stringLiteralKind) {
+        case StringLiteralKind.BASIC:
+            return buildBase64StringLiteral(buildContext);
+        case StringLiteralKind.UTF:
+            return buildUtfStringLiteral(buildContext);
+        default: {
+            const exhaustiveCheck = stringLiteralKind;
+            throw new InternalScannerError("Unreachable code reached, stringLiteralKind == " + exhaustiveCheck);
+        }
+    }
+}
+export function consumeAstNode(buildContext) {
+    const { cursor } = buildContext;
+    const currentState = buildContext.stateStack[buildContext.stateStack.length - 1];
+    const parentTypeId = cursor.type.id;
+    const parentTypeName = cursor.type.name;
+    let nodeKind;
+    if (cursor.type.isError) {
+        nodeKind = NodeKind.UNEXPECTED_ERROR;
+    }
+    else {
+        nodeKind = nodeKindByTokenTypeId.get(parentTypeId);
+    }
+    if (nodeKind === undefined) {
+        throw new InternalScannerError(`No nodeKind mapping found for token type id: ${parentTypeId} (${parentTypeName})`);
+    }
+    logger.debug(currentState.indent + "consuming AST node: " + NodeKind[nodeKind] + "...");
+    const childStack = {
+        isEndOfSiblings: false,
+        indent: currentState.indent + "  ",
+    };
+    buildContext.stateStack.push(childStack);
+    if (!cursor.firstChild()) {
+        throw new InternalScannerError(`Expected AST node to have children: ${NodeKind[nodeKind]}`);
+    }
+    let node;
+    switch (nodeKind) {
+        case NodeKind.ARRAY_DIMENSION:
+            node = consumeArrayDimension(buildContext, parentTypeId, parentTypeName);
+            break;
+        case NodeKind.CLASS_ID:
+            node = consumeClassId(buildContext, parentTypeId, parentTypeName);
+            break;
+        case NodeKind.EXPRESSION:
+            node = consumeExpression(buildContext, parentTypeId, parentTypeName);
+            break;
+        case NodeKind.STATEMENT:
+            node = consumeStatement(buildContext, parentTypeId, parentTypeName);
+            break;
+        case NodeKind.STRING_LITERAL:
+            node = consumeStringLiteral(buildContext, parentTypeId, parentTypeName);
+            break;
+        case NodeKind.AGGREGATE_OUTPUT_VALUE:
+            node = buildAggregateOutputValue(buildContext);
+            break;
+        case NodeKind.ALIGNED_MODIFIER:
+            node = buildAlignedModifier(buildContext);
+            break;
+        case NodeKind.ARRAY_ELEMENT_ACCESS:
+            node = buildArrayElementAccess(buildContext);
+            break;
+        case NodeKind.BIT_MODIFIER:
+            node = buildBitModifier(buildContext);
+            break;
+        case NodeKind.CASE_CLAUSE:
+            node = buildCaseClause(buildContext);
+            break;
+        case NodeKind.CLASS_MEMBER_ACCESS:
+            node = buildClassMemberAccess(buildContext);
+            break;
+        case NodeKind.DEFAULT_CLAUSE:
+            node = buildDefaultClause(buildContext);
+            break;
+        case NodeKind.ELEMENTARY_TYPE:
+            node = buildElementaryType(buildContext);
+            break;
+        case NodeKind.ELEMENTARY_TYPE_OUTPUT_VALUE:
+            node = buildElementaryTypeOutputValue(buildContext);
+            break;
+        case NodeKind.EXPANDABLE_MODIFIER:
+            node = buildExpandableModifier(buildContext);
+            break;
+        case NodeKind.EXTENDS_MODIFIER:
+            node = buildExtendsModifier(buildContext);
+            break;
+        case NodeKind.LENGTH_ATTRIBUTE:
+            node = buildLengthAttribute(buildContext);
+            break;
+        case NodeKind.MAP_ENTRY:
+            node = buildMapEntry(buildContext);
+            break;
+        case NodeKind.NUMBER_LITERAL:
+            node = buildMultipleCharacterLiteral(buildContext);
+            break;
+        case NodeKind.PARAMETER:
+            node = buildParameter(buildContext);
+            break;
+        case NodeKind.PARAMETER_LIST:
+            node = buildParameterList(buildContext);
+            break;
+        case NodeKind.PARAMETER_VALUE_LIST:
+            node = buildParameterValueList(buildContext);
+            break;
+        case NodeKind.SPECIFICATION:
+            node = buildSpecification(buildContext);
+            break;
+        case NodeKind.UNEXPECTED_ERROR:
+            node = buildUnexpectedError(buildContext);
+            break;
+        // These are node types that should be handled by other consumers
+        case NodeKind.IDENTIFIER:
+        case NodeKind.TOKEN:
+            throw new InternalScannerError(`consumeAstNode cannot consume node of kind: ${NodeKind[nodeKind]}`);
+        default: {
+            const exhaustiveCheck = nodeKind;
+            throw new InternalScannerError("Unreachable code reached, nodeKind == " + exhaustiveCheck);
+        }
+    }
+    if (!childStack.isEndOfSiblings) {
+        // skip any whitespace or missing error nodes as these are inserted by parser when recovering
+        consumeWhiteSpaceAndMissingErrors(buildContext);
+        if (!childStack.isEndOfSiblings) {
+            throw new InternalScannerError(`Expected to have consumed all child nodes of ${NodeKind[nodeKind]}, but some remain.`);
+        }
+    }
+    buildContext.stateStack.pop();
+    if (!cursor.parent()) {
+        throw new InternalScannerError(`Expected to move cursor back to parent of ${NodeKind[nodeKind]}, but failed.`);
+    }
+    logger.debug(currentState.indent + "...consumed node: " + NodeKind[nodeKind]);
+    return node;
+}

package/dist/src/ast/build/consume/consume-primitive.d.ts

@@ -0,0 +1,4 @@
+import type { BuildContext } from "../util/build-context.ts";
+import type { AbstractNode } from "../../node/abstract-node.ts";
+export declare function consumePrimitive(buildContext: BuildContext): AbstractNode;
+//# sourceMappingURL=consume-primitive.d.ts.map

package/dist/src/ast/build/consume/consume-primitive.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"consume-primitive.d.ts","sourceRoot":"","sources":["../../../../../src/ast/build/consume/consume-primitive.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAU7D,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAQhE,wBAAgB,gBAAgB,CAAC,YAAY,EAAE,YAAY,GAAG,YAAY,CAsCzE"}

package/dist/src/ast/build/consume/consume-primitive.js

@@ -0,0 +1,47 @@
+import getLogger from "../../../util/logger.js";
+import { buildToken } from "../node/build-token.js";
+import { NodeKind } from "../../node/enum/node-kind.js";
+import { buildBinaryLiteral } from "../node/build-binary-literal.js";
+import { buildDecimalLiteral } from "../node/build-decimal-literal.js";
+import { buildFloatingPointLiteral } from "../node/build-floating-point-literal.js";
+import { buildHexadecimalLiteral } from "../node/build-hexadecimal-literal.js";
+import { buildIdentifier } from "../node/build-identifier.js";
+import { buildIntegerLiteral } from "../node/build-integer-literal.js";
+import { InternalScannerError } from "../../../scanner-error.js";
+// Generated by Lezer from the SDL grammar
+import * as TokenTypeId from "../../../lezer/parser.terms.js";
+const logger = getLogger("consumePrimitive");
+export function consumePrimitive(buildContext) {
+    const { cursor } = buildContext;
+    const currentState = buildContext.stateStack[buildContext.stateStack.length - 1];
+    const token = buildToken(buildContext);
+    let node;
+    switch (cursor.type.id) {
+        case TokenTypeId.Identifier:
+            node = buildIdentifier(token);
+            break;
+        case TokenTypeId.HexadecimalLiteral:
+            node = buildHexadecimalLiteral(token);
+            break;
+        case TokenTypeId.IntegerLiteral:
+            node = buildIntegerLiteral(token);
+            break;
+        case TokenTypeId.BinaryLiteral:
+            node = buildBinaryLiteral(token);
+            break;
+        case TokenTypeId.DecimalLiteral:
+            node = buildDecimalLiteral(token);
+            break;
+        case TokenTypeId.FloatingPointLiteral:
+            node = buildFloatingPointLiteral(token);
+            break;
+        default:
+            throw new InternalScannerError(`Unsupported primitive type: ${cursor.type.name}`);
+    }
+    logger.debug(currentState.indent +
+        "consumed primitive node: " +
+        NodeKind[node.nodeKind] +
+        " " +
+        token.text.replaceAll("\n", "\\n"));
+    return node;
+}

package/dist/src/ast/build/consume/consume-trivia.d.ts

@@ -0,0 +1,8 @@
+import type { Trivia } from "../../node/trivia.ts";
+import type { BuildContext } from "../util/build-context.ts";
+/**
+ * Iterate through the syntax tree and convert comments or whitespace to Trivia
+ * until a non-comment or non-whitespace parse node is found.
+ */
+export declare function consumeTrivia(buildContext: BuildContext, isTrailing: boolean): Trivia[];
+//# sourceMappingURL=consume-trivia.d.ts.map

package/dist/src/ast/build/consume/consume-trivia.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"consume-trivia.d.ts","sourceRoot":"","sources":["../../../../../src/ast/build/consume/consume-trivia.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,sBAAsB,CAAC;AAEnD,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAsB7D;;;GAGG;AACH,wBAAgB,aAAa,CAAC,YAAY,EAAE,YAAY,EAAE,UAAU,EAAE,OAAO,GAAG,MAAM,EAAE,CAuDvF"}

package/dist/src/ast/build/consume/consume-trivia.js

@@ -0,0 +1,67 @@
+import { Text } from "@codemirror/state";
+import { TreeCursor } from "@lezer/common";
+import { getLocationFromTextPosition } from "../../../util/location-utils.js";
+import getLogger from "../../../util/logger.js";
+// Generated by Lezer from the SDL grammar
+import { Comment, Whitespace } from "../../../lezer/parser.terms.js";
+const logger = getLogger("consumeTrivia");
+function getCommentTrivia(cursor, text) {
+    return {
+        text: text.sliceString(cursor.from, cursor.to),
+        location: getLocationFromTextPosition(text, cursor.from),
+    };
+}
+function getBlankLineTrivia(cursor, text) {
+    return {
+        text: "\n",
+        location: getLocationFromTextPosition(text, cursor.from),
+    };
+}
+/**
+ * Iterate through the syntax tree and convert comments or whitespace to Trivia
+ * until a non-comment or non-whitespace parse node is found.
+ */
+export function consumeTrivia(buildContext, isTrailing) {
+    const { cursor, text } = buildContext;
+    const currentState = buildContext.stateStack[buildContext.stateStack.length - 1];
+    if (currentState.isEndOfSiblings) {
+        return [];
+    }
+    const trivia = [];
+    let noSibling = true;
+    do {
+        // Save comments
+        if (cursor.type.id === Comment) {
+            trivia.push(getCommentTrivia(cursor, text));
+            // If trailing, stop after first comment
+            if (isTrailing) {
+                // advance the cursor as we consumed the comment
+                noSibling = !cursor.nextSibling();
+                break;
+            }
+        } // Skip whitespace except for multiple new lines which are collapsed into a single blank line trivia
+        else if (cursor.type.id === Whitespace) {
+            const whitespace = text.sliceString(cursor.from, cursor.to);
+            const newLineCount = (whitespace.match(/\n/g) || []).length;
+            // If trailing, stop at first line break
+            if (isTrailing && newLineCount > 0) {
+                noSibling = false;
+                break;
+            }
+            if (newLineCount > 1) {
+                trivia.push(getBlankLineTrivia(cursor, text));
+            }
+        } // Otherwise stop at the first non-comment, non-whitespace node
+        else if (cursor.type.id !== Comment && cursor.type.id !== Whitespace) {
+            noSibling = false;
+            break;
+        }
+    } while (cursor.nextSibling());
+    currentState.isEndOfSiblings = noSibling;
+    if (trivia.length > 0) {
+        logger.debug(currentState.indent +
+            `consumed ${isTrailing ? "trailing" : "leading"} trivia: ` +
+            trivia.map((triviaEntry) => triviaEntry.text.replaceAll("\n", "\\n")).join(", "));
+    }
+    return trivia;
+}

package/dist/src/ast/build/consume/consume-white-space-and-missing-errors.d.ts

@@ -0,0 +1,3 @@
+import type { BuildContext } from "../util/build-context.ts";
+export declare function consumeWhiteSpaceAndMissingErrors(buildContext: BuildContext): void;
+//# sourceMappingURL=consume-white-space-and-missing-errors.d.ts.map

package/dist/src/ast/build/consume/consume-white-space-and-missing-errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"consume-white-space-and-missing-errors.d.ts","sourceRoot":"","sources":["../../../../../src/ast/build/consume/consume-white-space-and-missing-errors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAK7D,wBAAgB,iCAAiC,CAAC,YAAY,EAAE,YAAY,GAAG,IAAI,CAkBlF"}

package/dist/src/ast/build/consume/consume-white-space-and-missing-errors.js

@@ -0,0 +1,17 @@
+// Generated by Lezer from the SDL grammar
+import { Whitespace } from "../../../lezer/parser.terms.js";
+export function consumeWhiteSpaceAndMissingErrors(buildContext) {
+    const { cursor } = buildContext;
+    const currentState = buildContext.stateStack[buildContext.stateStack.length - 1];
+    if (currentState.isEndOfSiblings) {
+        return;
+    }
+    let noSibling = true;
+    do {
+        if (cursor.type.id !== Whitespace && !cursor.type.isError) {
+            noSibling = false;
+            break;
+        }
+    } while (cursor.nextSibling());
+    currentState.isEndOfSiblings = noSibling;
+}

package/dist/src/ast/build/node/build-aggregate-output-value.d.ts

@@ -0,0 +1,4 @@
+import { AggregateOutputValue } from "../../node/aggregate-output-value.ts";
+import type { BuildContext } from "../util/build-context.ts";
+export declare function buildAggregateOutputValue(buildContext: BuildContext): AggregateOutputValue;
+//# sourceMappingURL=build-aggregate-output-value.d.ts.map

package/dist/src/ast/build/node/build-aggregate-output-value.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"build-aggregate-output-value.d.ts","sourceRoot":"","sources":["../../../../../src/ast/build/node/build-aggregate-output-value.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,oBAAoB,EAAE,MAAM,sCAAsC,CAAC;AAG5E,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,0BAA0B,CAAC;AAM7D,wBAAgB,yBAAyB,CAAC,YAAY,EAAE,YAAY,GAAG,oBAAoB,CAwC1F"}