@mpeggroup/mpeg-sdl-parser 4.0.0

package/src/completion/rules/abstract-types.ts

@@ -0,0 +1,174 @@
+import { InternalScannerError } from "../../scanner-error.ts";
+
+// Generated by Lezer from the SDL grammar
+import * as TokenTypeId from "../../lezer/parser.terms.ts";
+
+export const binaryOperatorTypes: number[] = [];
+export const postfixOperatorTypes: number[] = [];
+export const unaryOperatorTypes: number[] = [];
+export const numberLiteralTypes: number[] = [];
+export const expressionTypes: number[] = [];
+export const statementTypes: number[] = [];
+
+/**
+ * Map parsed token type ID to AST token type enum.
+ */
+Object.values(TokenTypeId).forEach((tokenTypeId) => {
+  switch (tokenTypeId) {
+    case TokenTypeId.Multiplication:
+    case TokenTypeId.Division:
+    case TokenTypeId.Modulus:
+    case TokenTypeId.Addition:
+    case TokenTypeId.Subtraction:
+    case TokenTypeId.BitwiseShiftLeft:
+    case TokenTypeId.BitwiseShiftRight:
+    case TokenTypeId.RelationalLessThan:
+    case TokenTypeId.RelationalLessThanOrEqual:
+    case TokenTypeId.RelationalGreaterThan:
+    case TokenTypeId.RelationalGreaterThanOrEqual:
+    case TokenTypeId.RelationalEqual:
+    case TokenTypeId.RelationalNotEqual:
+    case TokenTypeId.BitwiseAnd:
+    case TokenTypeId.BitwiseOr:
+    case TokenTypeId.LogicalAnd:
+    case TokenTypeId.LogicalOr:
+      binaryOperatorTypes.push(tokenTypeId);
+      break;
+    case TokenTypeId.PostfixIncrement:
+    case TokenTypeId.PostfixDecrement:
+      postfixOperatorTypes.push(tokenTypeId);
+      break;
+    case TokenTypeId.UnaryPlus:
+    case TokenTypeId.UnaryNegation:
+      unaryOperatorTypes.push(tokenTypeId);
+      break;
+    case TokenTypeId.BinaryLiteral:
+    case TokenTypeId.HexadecimalLiteral:
+    case TokenTypeId.MultipleCharacterLiteral:
+    case TokenTypeId.IntegerLiteral:
+    case TokenTypeId.DecimalLiteral:
+    case TokenTypeId.FloatingPointLiteral:
+      numberLiteralTypes.push(tokenTypeId);
+      break;
+    case TokenTypeId.UnaryExpression:
+    case TokenTypeId.BinaryExpression:
+      expressionTypes.push(tokenTypeId);
+      break;
+    case TokenTypeId.CompoundStatement:
+    case TokenTypeId.IfStatement:
+    case TokenTypeId.SwitchStatement:
+    case TokenTypeId.ForStatement:
+    case TokenTypeId.DoStatement:
+    case TokenTypeId.WhileStatement:
+    case TokenTypeId.ExpressionStatement:
+    case TokenTypeId.ElementaryTypeDefinition:
+    case TokenTypeId.MapDefinition:
+    case TokenTypeId.ClassDefinition:
+    case TokenTypeId.StringDefinition:
+    case TokenTypeId.ArrayDefinition:
+    case TokenTypeId.ComputedElementaryTypeDefinition:
+    case TokenTypeId.ComputedArrayDefinition:
+      statementTypes.push(tokenTypeId);
+      break;
+
+    // Not currently mapped for completion rules
+    case TokenTypeId.AlignedModifier:
+    case TokenTypeId.AggregateOutputValue:
+    case TokenTypeId.ClassDeclaration:
+    case TokenTypeId.MapDeclaration:
+    case TokenTypeId.AssignmentExpression:
+    case TokenTypeId.LengthofExpression:
+    case TokenTypeId.ArrayElementAccess:
+    case TokenTypeId.Base64StringLiteral:
+    case TokenTypeId.UtfStringLiteral:
+    case TokenTypeId.BitModifier:
+    case TokenTypeId.CaseClause:
+    case TokenTypeId.ClassId:
+    case TokenTypeId.ClassIdRange:
+    case TokenTypeId.ExtendedClassIdRange:
+    case TokenTypeId.ClassMemberAccess:
+    case TokenTypeId.DefaultClause:
+    case TokenTypeId.ElementaryType:
+    case TokenTypeId.ElementaryTypeOutputValue:
+    case TokenTypeId.ExpandableModifier:
+    case TokenTypeId.ExplicitArrayDimension:
+    case TokenTypeId.ImplicitArrayDimension:
+    case TokenTypeId.PartialArrayDimension:
+    case TokenTypeId.ExtendsModifier:
+    case TokenTypeId.LengthAttribute:
+    case TokenTypeId.MapEntry:
+    case TokenTypeId.Parameter:
+    case TokenTypeId.ParameterList:
+    case TokenTypeId.ParameterValueList:
+    case TokenTypeId.Specification:
+    case TokenTypeId.AlignmentBitCount8:
+    case TokenTypeId.AlignmentBitCount16:
+    case TokenTypeId.AlignmentBitCount32:
+    case TokenTypeId.AlignmentBitCount64:
+    case TokenTypeId.AlignmentBitCount128:
+    case TokenTypeId.Base64StringLiteralCharacters:
+    case TokenTypeId.Identifier:
+    case TokenTypeId.MultipleCharacterLiteralCharacters:
+    case TokenTypeId.UtfStringLiteralCharacters:
+
+    // Trivia
+    case TokenTypeId.Comment:
+    case TokenTypeId.Whitespace:
+
+    // punctuation
+    case TokenTypeId.Assignment:
+    case TokenTypeId.CloseBrace:
+    case TokenTypeId.CloseBracket:
+    case TokenTypeId.CloseParenthesis:
+    case TokenTypeId.Colon:
+    case TokenTypeId.Comma:
+    case TokenTypeId.DoubleQuote:
+    case TokenTypeId.LookAhead:
+    case TokenTypeId.OpenBrace:
+    case TokenTypeId.OpenBracket:
+    case TokenTypeId.OpenParenthesis:
+    case TokenTypeId.Period:
+    case TokenTypeId.RangeOperator:
+    case TokenTypeId.Semicolon:
+    case TokenTypeId.SingleQuote:
+    case TokenTypeId.UtfPrefix:
+
+    // keywords
+    case TokenTypeId._break:
+    case TokenTypeId._case:
+    case TokenTypeId._class:
+    case TokenTypeId._const:
+    case TokenTypeId._default:
+    case TokenTypeId._do:
+    case TokenTypeId._else:
+    case TokenTypeId._extends:
+    case TokenTypeId._for:
+    case TokenTypeId._if:
+    case TokenTypeId._switch:
+    case TokenTypeId._while:
+    case TokenTypeId.abstract:
+    case TokenTypeId.aligned:
+    case TokenTypeId.base64string:
+    case TokenTypeId.bit:
+    case TokenTypeId.computed:
+    case TokenTypeId.expandable:
+    case TokenTypeId.float:
+    case TokenTypeId.int:
+    case TokenTypeId.legacy:
+    case TokenTypeId.lengthof:
+    case TokenTypeId.map:
+    case TokenTypeId.reserved:
+    case TokenTypeId.unsigned:
+    case TokenTypeId.utf16string:
+    case TokenTypeId.utf8list:
+    case TokenTypeId.utf8string:
+    case TokenTypeId.utfstring:
+      break;
+    default: {
+      const exhaustiveCheck: never = tokenTypeId;
+      throw new InternalScannerError(
+        "Unreachable code reached, tokenTypeId == " + exhaustiveCheck,
+      );
+    }
+  }
+});

package/src/completion/rules/aggregate-output-value-rules.ts

@@ -0,0 +1,48 @@
+// Generated by Lezer from the SDL grammar
+import * as TokenTypeId from "../../lezer/parser.terms.ts";
+
+import { numberLiteralTypes } from "./abstract-types.ts";
+
+export const aggregateOutputValueRules = [
+  {
+    previous: -1,
+    expected: TokenTypeId.OpenBrace,
+  },
+  {
+    previous: TokenTypeId.OpenBrace,
+    expected: [
+      TokenTypeId.ElementaryTypeOutputValue,
+      TokenTypeId.OpenBrace,
+      ...numberLiteralTypes,
+    ],
+  },
+  {
+    previous: TokenTypeId.Comma,
+    expected: [
+      TokenTypeId.ElementaryTypeOutputValue,
+      TokenTypeId.OpenBrace,
+      ...numberLiteralTypes,
+    ],
+  },
+  {
+    previous: TokenTypeId.ElementaryTypeOutputValue,
+    expected: [
+      TokenTypeId.Comma,
+      TokenTypeId.CloseBrace,
+    ],
+  },
+  {
+    previous: TokenTypeId.CloseBrace,
+    expected: [
+      TokenTypeId.Comma,
+      TokenTypeId.CloseBrace,
+    ],
+  },
+  ...numberLiteralTypes.map((type) => ({
+    previous: type,
+    expected: [
+      TokenTypeId.Comma,
+      TokenTypeId.CloseBrace,
+    ],
+  })),
+];

package/src/completion/rules/aligned-modifier-rules.ts

@@ -0,0 +1,45 @@
+// Generated by Lezer from the SDL grammar
+import * as TokenTypeId from "../../lezer/parser.terms.ts";
+
+export const alignedModifierRules = [
+  {
+    previous: -1,
+    expected: [
+      TokenTypeId.aligned,
+    ],
+  },
+  {
+    previous: TokenTypeId.OpenParenthesis,
+    expected: [
+      TokenTypeId.AlignmentBitCount8,
+      TokenTypeId.AlignmentBitCount16,
+      TokenTypeId.AlignmentBitCount32,
+      TokenTypeId.AlignmentBitCount64,
+      TokenTypeId.AlignmentBitCount128,
+    ],
+  },
+  {
+    previous: TokenTypeId.AlignmentBitCount8,
+    expected: TokenTypeId.CloseParenthesis,
+  },
+  {
+    previous: TokenTypeId.AlignmentBitCount16,
+    expected: TokenTypeId.CloseParenthesis,
+  },
+  {
+    previous: TokenTypeId.AlignmentBitCount32,
+    expected: TokenTypeId.CloseParenthesis,
+  },
+  {
+    previous: TokenTypeId.AlignmentBitCount64,
+    expected: TokenTypeId.CloseParenthesis,
+  },
+  {
+    previous: TokenTypeId.AlignmentBitCount128,
+    expected: TokenTypeId.CloseParenthesis,
+  },
+  {
+    previous: TokenTypeId.AlignmentBitCount8,
+    expected: TokenTypeId.CloseParenthesis,
+  },
+];

package/src/completion/rules/array-definition-rules.ts

@@ -0,0 +1,87 @@
+// Generated by Lezer from the SDL grammar
+import * as TokenTypeId from "../../lezer/parser.terms.ts";
+
+export const arrayDefinitionRules = [
+  {
+    previous: -1,
+    expected: [
+      TokenTypeId.reserved,
+      TokenTypeId.legacy,
+      TokenTypeId.AlignedModifier,
+      TokenTypeId.ElementaryType,
+      TokenTypeId.Identifier,
+    ],
+  },
+  {
+    previous: TokenTypeId.reserved,
+    expected: [
+      TokenTypeId.AlignedModifier,
+      TokenTypeId.ElementaryType,
+      TokenTypeId.Identifier,
+    ],
+  },
+  {
+    previous: TokenTypeId.legacy,
+    expected: [
+      TokenTypeId.AlignedModifier,
+      TokenTypeId.ElementaryType,
+      TokenTypeId.Identifier,
+    ],
+  },
+  {
+    previous: TokenTypeId.AlignedModifier,
+    expected: [TokenTypeId.ElementaryType, TokenTypeId.Identifier],
+  },
+  {
+    previous: TokenTypeId.ElementaryType,
+    expected: TokenTypeId.LengthAttribute,
+  },
+  {
+    previous: TokenTypeId.LengthAttribute,
+    expected: TokenTypeId.Identifier,
+  },
+  {
+    previous: [-1, TokenTypeId.Identifier],
+    expected: TokenTypeId.Identifier,
+  },
+  {
+    previous: [TokenTypeId.reserved, TokenTypeId.Identifier],
+    expected: TokenTypeId.Identifier,
+  },
+  {
+    previous: [TokenTypeId.legacy, TokenTypeId.Identifier],
+    expected: TokenTypeId.Identifier,
+  },
+  {
+    previous: [TokenTypeId.AlignedModifier, TokenTypeId.Identifier],
+    expected: TokenTypeId.Identifier,
+  },
+  {
+    previous: [TokenTypeId.LengthAttribute, TokenTypeId.Identifier],
+    expected: [
+      TokenTypeId.ImplicitArrayDimension,
+      TokenTypeId.ExplicitArrayDimension,
+      TokenTypeId.PartialArrayDimension,
+    ],
+  },
+  {
+    previous: [TokenTypeId.Identifier, TokenTypeId.Identifier],
+    expected: [
+      TokenTypeId.ImplicitArrayDimension,
+      TokenTypeId.ExplicitArrayDimension,
+      TokenTypeId.PartialArrayDimension,
+    ],
+  },
+  {
+    previous: TokenTypeId.ImplicitArrayDimension,
+    expected: TokenTypeId.Semicolon,
+  },
+  {
+    previous: TokenTypeId.ExplicitArrayDimension,
+    expected: [TokenTypeId.ExplicitArrayDimension, TokenTypeId.Semicolon],
+  },
+  {
+    previous: TokenTypeId.PartialArrayDimension,
+    expected: [TokenTypeId.PartialArrayDimension, TokenTypeId.Semicolon],
+  },
+];

package/src/completion/rules/array-element-access-rules.ts

@@ -0,0 +1,22 @@
+import { binaryOperatorTypes, expressionTypes } from "./abstract-types.ts";
+
+// Generated by Lezer from the SDL grammar
+import * as TokenTypeId from "../../lezer/parser.terms.ts";
+
+export const arrayElementAccessRules = [
+  {
+    previous: -1,
+    expected: TokenTypeId.OpenBracket,
+  },
+  {
+    previous: TokenTypeId.OpenBracket,
+    expected: expressionTypes,
+  },
+  ...expressionTypes.map((expressionType) => ({
+    previous: expressionType,
+    expected: [
+      TokenTypeId.CloseBracket,
+      ...binaryOperatorTypes,
+    ],
+  })),
+];

package/src/completion/rules/assignment-expression-rules.ts

@@ -0,0 +1,19 @@
+import { expressionTypes } from "./abstract-types.ts";
+
+// Generated by Lezer from the SDL grammar
+import * as TokenTypeId from "../../lezer/parser.terms.ts";
+
+export const assignmentExpressionRules = [
+  {
+    previous: -1,
+    expected: expressionTypes,
+  },
+  ...expressionTypes.map((expressionType) => ({
+    previous: expressionType,
+    expected: TokenTypeId.Assignment,
+  })),
+  {
+    previous: TokenTypeId.Assignment,
+    expected: expressionTypes,
+  },
+];

package/src/completion/rules/binary-expression-rules.ts

@@ -0,0 +1,23 @@
+import { binaryOperatorTypes, expressionTypes } from "./abstract-types.ts";
+
+// Generated by Lezer from the SDL grammar
+import * as TokenTypeId from "../../lezer/parser.terms.ts";
+
+export const binaryExpressionRules = [
+  {
+    previous: -1,
+    expected: TokenTypeId.UnaryExpression,
+  },
+  ...expressionTypes.map((type) => {
+    return {
+      previous: type,
+      expected: binaryOperatorTypes,
+    };
+  }),
+  ...binaryOperatorTypes.map((type) => {
+    return {
+      previous: type,
+      expected: expressionTypes,
+    };
+  }),
+];

package/src/completion/rules/bit-modifier-rules.ts

@@ -0,0 +1,25 @@
+// Generated by Lezer from the SDL grammar
+import * as TokenTypeId from "../../lezer/parser.terms.ts";
+
+export const bitModifierRules = [
+  { previous: -1, expected: TokenTypeId.Colon },
+  { previous: TokenTypeId.Colon, expected: TokenTypeId.bit },
+  { previous: TokenTypeId.bit, expected: TokenTypeId.OpenParenthesis },
+  {
+    previous: TokenTypeId.OpenParenthesis,
+    expected: TokenTypeId.IntegerLiteral,
+  },
+  {
+    previous: TokenTypeId.IntegerLiteral,
+    expected: TokenTypeId.CloseParenthesis,
+  },
+  {
+    previous: TokenTypeId.CloseParenthesis,
+    expected: [TokenTypeId.Identifier, TokenTypeId.ExtendedClassIdRange],
+  },
+  { previous: TokenTypeId.Identifier, expected: TokenTypeId.Assignment },
+  {
+    previous: TokenTypeId.Assignment,
+    expected: TokenTypeId.ExtendedClassIdRange,
+  },
+];

package/src/completion/rules/case-clause-rules.ts

@@ -0,0 +1,39 @@
+import { numberLiteralTypes, statementTypes } from "./abstract-types.ts";
+
+// Generated by Lezer from the SDL grammar
+import * as TokenTypeId from "../../lezer/parser.terms.ts";
+
+export const caseClauseRules = [
+  {
+    previous: -1,
+    expected: TokenTypeId._case,
+  },
+  {
+    previous: TokenTypeId._case,
+    expected: numberLiteralTypes,
+  },
+  ...numberLiteralTypes.map((type) => ({
+    previous: type,
+    expected: TokenTypeId.Colon,
+  })),
+  {
+    previous: TokenTypeId.Colon,
+    expected: [...statementTypes, TokenTypeId.OpenBrace, TokenTypeId._break],
+  },
+  ...statementTypes.map((type) => ({
+    previous: type,
+    expected: [...statementTypes, TokenTypeId._break],
+  })),
+  {
+    previous: TokenTypeId._break,
+    expected: TokenTypeId.Semicolon,
+  },
+  {
+    previous: TokenTypeId.OpenBrace,
+    expected: statementTypes,
+  },
+  {
+    previous: TokenTypeId.Semicolon,
+    expected: TokenTypeId.CloseBrace,
+  },
+];

package/src/completion/rules/class-declaration-rules.ts

@@ -0,0 +1,81 @@
+import { statementTypes } from "./abstract-types.ts";
+
+// Generated by Lezer from the SDL grammar
+import * as TokenTypeId from "../../lezer/parser.terms.ts";
+
+export const classDeclarationRules = [
+  {
+    previous: -1,
+    expected: [
+      TokenTypeId.AlignedModifier,
+      TokenTypeId.ExpandableModifier,
+      TokenTypeId.abstract,
+      TokenTypeId._class,
+    ],
+  },
+  {
+    previous: TokenTypeId.AlignedModifier,
+    expected: [
+      TokenTypeId.ExpandableModifier,
+      TokenTypeId.abstract,
+      TokenTypeId._class,
+    ],
+  },
+  {
+    previous: TokenTypeId.ExpandableModifier,
+    expected: [
+      TokenTypeId.abstract,
+      TokenTypeId._class,
+    ],
+  },
+  {
+    previous: TokenTypeId.abstract,
+    expected: TokenTypeId._class,
+  },
+  {
+    previous: TokenTypeId._class,
+    expected: TokenTypeId.Identifier,
+  },
+  {
+    previous: TokenTypeId.Identifier,
+    expected: [
+      TokenTypeId.ParameterList,
+      TokenTypeId.ExtendsModifier,
+      TokenTypeId.BitModifier,
+      TokenTypeId.OpenBrace,
+    ],
+  },
+  {
+    previous: TokenTypeId.ParameterList,
+    expected: [
+      TokenTypeId.ExtendsModifier,
+      TokenTypeId.BitModifier,
+      TokenTypeId.OpenBrace,
+    ],
+  },
+  {
+    previous: TokenTypeId.ExtendsModifier,
+    expected: [
+      TokenTypeId.BitModifier,
+      TokenTypeId.OpenBrace,
+    ],
+  },
+  {
+    previous: TokenTypeId.BitModifier,
+    expected: TokenTypeId.OpenBrace,
+  },
+  {
+    previous: TokenTypeId.OpenBrace,
+    expected: [
+      ...statementTypes,
+      TokenTypeId.CloseBrace,
+    ],
+  },
+  ...statementTypes.map((type) => ({
+    previous: type,
+    expected: [
+      ...statementTypes,
+      TokenTypeId.CloseBrace,
+    ],
+  })),
+];

package/src/completion/rules/class-definition-rules.ts

@@ -0,0 +1,28 @@
+// Generated by Lezer from the SDL grammar
+import * as TokenTypeId from "../../lezer/parser.terms.ts";
+
+export const classDefinitionRules = [
+  {
+    previous: -1,
+    expected: [
+      TokenTypeId.legacy,
+      TokenTypeId.Identifier,
+    ],
+  },
+  {
+    previous: TokenTypeId.legacy,
+    expected: TokenTypeId.Identifier,
+  },
+  {
+    previous: TokenTypeId.Identifier,
+    expected: TokenTypeId.Identifier,
+  },
+  {
+    previous: [TokenTypeId.Identifier, TokenTypeId.Identifier],
+    expected: [TokenTypeId.ParameterValueList, TokenTypeId.Semicolon],
+  },
+  {
+    previous: TokenTypeId.ParameterValueList,
+    expected: TokenTypeId.Semicolon,
+  },
+];

package/src/completion/rules/class-id-range-rules.ts

@@ -0,0 +1,17 @@
+// Generated by Lezer from the SDL grammar
+import * as TokenTypeId from "../../lezer/parser.terms.ts";
+
+export const classIdRangeRules = [
+  {
+    previous: -1,
+    expected: TokenTypeId.ClassId,
+  },
+  {
+    previous: TokenTypeId.ClassId,
+    expected: TokenTypeId.RangeOperator,
+  },
+  {
+    previous: TokenTypeId.RangeOperator,
+    expected: TokenTypeId.ClassId,
+  },
+];

package/src/completion/rules/class-id-rules.ts

@@ -0,0 +1,9 @@
+// Generated by Lezer from the SDL grammar
+import * as TokenTypeId from "../../lezer/parser.terms.ts";
+
+export const classIdRules = [
+  {
+    previous: -1,
+    expected: TokenTypeId.IntegerLiteral,
+  },
+];

package/src/completion/rules/class-member-access-rules.ts

@@ -0,0 +1,7 @@
+// Generated by Lezer from the SDL grammar
+import * as TokenTypeId from "../../lezer/parser.terms.ts";
+
+export const classMemberAccessRules = [
+  { previous: -1, expected: TokenTypeId.Period },
+  { previous: TokenTypeId.Period, expected: TokenTypeId.Identifier },
+];

package/src/completion/rules/compound-statement-rules.ts

@@ -0,0 +1,25 @@
+import { statementTypes } from "./abstract-types.ts";
+
+// Generated by Lezer from the SDL grammar
+import * as TokenTypeId from "../../lezer/parser.terms.ts";
+
+export const compoundStatementRules = [
+  {
+    previous: -1,
+    expected: TokenTypeId.OpenBrace,
+  },
+  {
+    previous: TokenTypeId.OpenBrace,
+    expected: [
+      ...statementTypes,
+      TokenTypeId.CloseBrace,
+    ],
+  },
+  ...statementTypes.map((type) => ({
+    previous: type,
+    expected: [
+      ...statementTypes,
+      TokenTypeId.CloseBrace,
+    ],
+  })),
+];

package/src/completion/rules/computed-array-definition-rules.ts

@@ -0,0 +1,25 @@
+// Generated by Lezer from the SDL grammar
+import * as TokenTypeId from "../../lezer/parser.terms.ts";
+
+export const computedArrayDefinitionRules = [
+  {
+    previous: -1,
+    expected: TokenTypeId.computed,
+  },
+  {
+    previous: TokenTypeId.computed,
+    expected: TokenTypeId.ElementaryType,
+  },
+  {
+    previous: TokenTypeId.ElementaryType,
+    expected: TokenTypeId.Identifier,
+  },
+  {
+    previous: TokenTypeId.Identifier,
+    expected: TokenTypeId.ExplicitArrayDimension,
+  },
+  {
+    previous: TokenTypeId.ExplicitArrayDimension,
+    expected: [TokenTypeId.ExplicitArrayDimension, TokenTypeId.Semicolon],
+  },
+];