From 7fe5456300f6c25d80b340af897ab5607925873a Mon Sep 17 00:00:00 2001 From: Christian Schneider Date: Tue, 24 Jun 2025 13:00:48 +0200 Subject: [PATCH 1/2] langium grammar: derived explicitly defined AST types, introduced dedicated AST type `TerminalElement` * updated grammar --- .../langium/src/grammar/generated/grammar.ts | 2259 +++++++++++++++-- .../src/grammar/langium-grammar.langium | 179 +- .../langium/src/grammar/langium-types.langium | 241 ++ .../src/grammar/validation/validator.ts | 2 +- .../langium/src/languages/generated/ast.ts | 254 +- 5 files changed, 2505 insertions(+), 430 deletions(-) create mode 100644 packages/langium/src/grammar/langium-types.langium diff --git a/packages/langium/src/grammar/generated/grammar.ts b/packages/langium/src/grammar/generated/grammar.ts index 5c610a087..79714d3b5 100644 --- a/packages/langium/src/grammar/generated/grammar.ts +++ b/packages/langium/src/grammar/generated/grammar.ts @@ -11,11 +11,15 @@ export const LangiumGrammarGrammar = (): Grammar => loadedLangiumGrammarGrammar "$type": "Grammar", "isDeclared": true, "name": "LangiumGrammar", + "imports": [], "rules": [ { "$type": "ParserRule", "entry": true, "name": "Grammar", + "returnType": { + "$ref": "#/interfaces@6" + }, "definition": { "$type": "Group", "elements": [ @@ -109,6 +113,9 @@ export const LangiumGrammarGrammar = (): Grammar => loadedLangiumGrammarGrammar { "$type": "ParserRule", "name": "Interface", + "returnType": { + "$ref": "#/interfaces@12" + }, "definition": { "$type": "Group", "elements": [ @@ -142,7 +149,7 @@ export const LangiumGrammarGrammar = (): Grammar => loadedLangiumGrammarGrammar "terminal": { "$type": "CrossReference", "type": { - "$ref": "#/types@0" + "$ref": "#/types@1" }, "terminal": { "$type": "RuleCall", @@ -168,7 +175,7 @@ export const LangiumGrammarGrammar = (): Grammar => loadedLangiumGrammarGrammar "terminal": { "$type": "CrossReference", "type": { - "$ref": "#/types@0" + "$ref": "#/types@1" }, "terminal": { "$type": "RuleCall", @@ -221,6 +228,9 @@ export const LangiumGrammarGrammar = (): Grammar => loadedLangiumGrammarGrammar { "$type": "ParserRule", "name": "TypeAttribute", + "returnType": { + "$ref": "#/interfaces@25" + }, "definition": { "$type": "Group", "elements": [ @@ -298,6 +308,9 @@ export const LangiumGrammarGrammar = (): Grammar => loadedLangiumGrammarGrammar { "$type": "ParserRule", "name": "ValueLiteral", + "returnType": { + "$ref": "#/types@7" + }, "definition": { "$type": "Alternatives", "elements": [ @@ -338,6 +351,9 @@ export const LangiumGrammarGrammar = (): Grammar => loadedLangiumGrammarGrammar { "$type": "ParserRule", "name": "StringLiteral", + "returnType": { + "$ref": "#/interfaces@22" + }, "definition": { "$type": "Assignment", "feature": "value", @@ -357,6 +373,9 @@ export const LangiumGrammarGrammar = (): Grammar => loadedLangiumGrammarGrammar { "$type": "ParserRule", "name": "NumberLiteral", + "returnType": { + "$ref": "#/interfaces@15" + }, "definition": { "$type": "Assignment", "feature": "value", @@ -376,6 +395,9 @@ export const LangiumGrammarGrammar = (): Grammar => loadedLangiumGrammarGrammar { "$type": "ParserRule", "name": "BooleanLiteral", + "returnType": { + "$ref": "#/interfaces@3" + }, "definition": { "$type": "Alternatives", "elements": [ @@ -401,6 +423,9 @@ export const LangiumGrammarGrammar = (): Grammar => loadedLangiumGrammarGrammar { "$type": "ParserRule", "name": "ArrayLiteral", + "returnType": { + "$ref": "#/interfaces@1" + }, "definition": { "$type": "Group", "elements": [ @@ -461,6 +486,9 @@ export const LangiumGrammarGrammar = (): Grammar => loadedLangiumGrammarGrammar { "$type": "ParserRule", "name": "TypeDefinition", + "returnType": { + "$ref": "#/types@6" + }, "definition": { "$type": "RuleCall", "rule": { @@ -475,9 +503,8 @@ export const LangiumGrammarGrammar = (): Grammar => loadedLangiumGrammarGrammar { "$type": "ParserRule", "name": "UnionType", - "inferredType": { - "$type": "InferredType", - "name": "TypeDefinition" + "returnType": { + "$ref": "#/types@6" }, "definition": { "$type": "Group", @@ -494,9 +521,8 @@ export const LangiumGrammarGrammar = (): Grammar => loadedLangiumGrammarGrammar "elements": [ { "$type": "Action", - "inferredType": { - "$type": "InferredType", - "name": "UnionType" + "type": { + "$ref": "#/interfaces@26" }, "feature": "types", "operator": "+=" @@ -535,9 +561,8 @@ export const LangiumGrammarGrammar = (): Grammar => loadedLangiumGrammarGrammar { "$type": "ParserRule", "name": "ArrayType", - "inferredType": { - "$type": "InferredType", - "name": "TypeDefinition" + "returnType": { + "$ref": "#/types@6" }, "definition": { "$type": "Group", @@ -554,9 +579,8 @@ export const LangiumGrammarGrammar = (): Grammar => loadedLangiumGrammarGrammar "elements": [ { "$type": "Action", - "inferredType": { - "$type": "InferredType", - "name": "ArrayType" + "type": { + "$ref": "#/interfaces@2" }, "feature": "elementType", "operator": "=" @@ -581,9 +605,8 @@ export const LangiumGrammarGrammar = (): Grammar => loadedLangiumGrammarGrammar { "$type": "ParserRule", "name": "ReferenceType", - "inferredType": { - "$type": "InferredType", - "name": "TypeDefinition" + "returnType": { + "$ref": "#/types@6" }, "definition": { "$type": "Alternatives", @@ -600,9 +623,8 @@ export const LangiumGrammarGrammar = (): Grammar => loadedLangiumGrammarGrammar "elements": [ { "$type": "Action", - "inferredType": { - "$type": "InferredType", - "name": "ReferenceType" + "type": { + "$ref": "#/interfaces@19" } }, { @@ -632,9 +654,8 @@ export const LangiumGrammarGrammar = (): Grammar => loadedLangiumGrammarGrammar { "$type": "ParserRule", "name": "SimpleType", - "inferredType": { - "$type": "InferredType", - "name": "TypeDefinition" + "returnType": { + "$ref": "#/types@6" }, "definition": { "$type": "Alternatives", @@ -664,9 +685,8 @@ export const LangiumGrammarGrammar = (): Grammar => loadedLangiumGrammarGrammar "elements": [ { "$type": "Action", - "inferredType": { - "$type": "InferredType", - "name": "SimpleType" + "type": { + "$ref": "#/interfaces@21" } }, { @@ -679,7 +699,7 @@ export const LangiumGrammarGrammar = (): Grammar => loadedLangiumGrammarGrammar "terminal": { "$type": "CrossReference", "type": { - "$ref": "#/types@0" + "$ref": "#/types@1" }, "terminal": { "$type": "RuleCall", @@ -761,6 +781,9 @@ export const LangiumGrammarGrammar = (): Grammar => loadedLangiumGrammarGrammar { "$type": "ParserRule", "name": "Type", + "returnType": { + "$ref": "#/interfaces@24" + }, "definition": { "$type": "Group", "elements": [ @@ -810,6 +833,9 @@ export const LangiumGrammarGrammar = (): Grammar => loadedLangiumGrammarGrammar { "$type": "ParserRule", "name": "AbstractRule", + "returnType": { + "$ref": "#/types@0" + }, "definition": { "$type": "Alternatives", "elements": [ @@ -843,6 +869,9 @@ export const LangiumGrammarGrammar = (): Grammar => loadedLangiumGrammarGrammar { "$type": "ParserRule", "name": "GrammarImport", + "returnType": { + "$ref": "#/interfaces@7" + }, "definition": { "$type": "Group", "elements": [ @@ -876,6 +905,9 @@ export const LangiumGrammarGrammar = (): Grammar => loadedLangiumGrammarGrammar { "$type": "ParserRule", "name": "ParserRule", + "returnType": { + "$ref": "#/interfaces@18" + }, "definition": { "$type": "Group", "elements": [ @@ -930,7 +962,7 @@ export const LangiumGrammarGrammar = (): Grammar => loadedLangiumGrammarGrammar "terminal": { "$type": "CrossReference", "type": { - "$ref": "#/types@0" + "$ref": "#/types@1" }, "terminal": { "$type": "RuleCall", @@ -1011,6 +1043,9 @@ export const LangiumGrammarGrammar = (): Grammar => loadedLangiumGrammarGrammar { "$type": "ParserRule", "name": "InfixRule", + "returnType": { + "$ref": "#/interfaces@9" + }, "definition": { "$type": "Group", "elements": [ @@ -1070,6 +1105,9 @@ export const LangiumGrammarGrammar = (): Grammar => loadedLangiumGrammarGrammar { "$type": "ParserRule", "name": "InfixRuleOperators", + "returnType": { + "$ref": "#/interfaces@11" + }, "definition": { "$type": "Group", "elements": [ @@ -1116,6 +1154,9 @@ export const LangiumGrammarGrammar = (): Grammar => loadedLangiumGrammarGrammar { "$type": "ParserRule", "name": "InfixRuleOperatorList", + "returnType": { + "$ref": "#/interfaces@10" + }, "definition": { "$type": "Group", "elements": [ @@ -1211,6 +1252,9 @@ export const LangiumGrammarGrammar = (): Grammar => loadedLangiumGrammarGrammar "name": "imperative" } ], + "returnType": { + "$ref": "#/interfaces@8" + }, "definition": { "$type": "Group", "elements": [ @@ -1350,6 +1394,9 @@ export const LangiumGrammarGrammar = (): Grammar => loadedLangiumGrammarGrammar { "$type": "ParserRule", "name": "Parameter", + "returnType": { + "$ref": "#/interfaces@16" + }, "definition": { "$type": "Assignment", "feature": "name", @@ -1369,9 +1416,8 @@ export const LangiumGrammarGrammar = (): Grammar => loadedLangiumGrammarGrammar { "$type": "ParserRule", "name": "Alternatives", - "inferredType": { - "$type": "InferredType", - "name": "AbstractElement" + "returnType": { + "$ref": "#/interfaces@0" }, "definition": { "$type": "Group", @@ -1388,9 +1434,8 @@ export const LangiumGrammarGrammar = (): Grammar => loadedLangiumGrammarGrammar "elements": [ { "$type": "Action", - "inferredType": { - "$type": "InferredType", - "name": "Alternatives" + "type": { + "$ref": "#/interfaces@28" }, "feature": "elements", "operator": "+=" @@ -1429,9 +1474,8 @@ export const LangiumGrammarGrammar = (): Grammar => loadedLangiumGrammarGrammar { "$type": "ParserRule", "name": "ConditionalBranch", - "inferredType": { - "$type": "InferredType", - "name": "AbstractElement" + "returnType": { + "$ref": "#/interfaces@0" }, "definition": { "$type": "Alternatives", @@ -1448,9 +1492,8 @@ export const LangiumGrammarGrammar = (): Grammar => loadedLangiumGrammarGrammar "elements": [ { "$type": "Action", - "inferredType": { - "$type": "InferredType", - "name": "Group" + "type": { + "$ref": "#/interfaces@33" } }, { @@ -1497,9 +1540,8 @@ export const LangiumGrammarGrammar = (): Grammar => loadedLangiumGrammarGrammar { "$type": "ParserRule", "name": "UnorderedGroup", - "inferredType": { - "$type": "InferredType", - "name": "AbstractElement" + "returnType": { + "$ref": "#/interfaces@0" }, "definition": { "$type": "Group", @@ -1516,9 +1558,8 @@ export const LangiumGrammarGrammar = (): Grammar => loadedLangiumGrammarGrammar "elements": [ { "$type": "Action", - "inferredType": { - "$type": "InferredType", - "name": "UnorderedGroup" + "type": { + "$ref": "#/interfaces@42" }, "feature": "elements", "operator": "+=" @@ -1557,9 +1598,8 @@ export const LangiumGrammarGrammar = (): Grammar => loadedLangiumGrammarGrammar { "$type": "ParserRule", "name": "Group", - "inferredType": { - "$type": "InferredType", - "name": "AbstractElement" + "returnType": { + "$ref": "#/interfaces@0" }, "definition": { "$type": "Group", @@ -1576,9 +1616,8 @@ export const LangiumGrammarGrammar = (): Grammar => loadedLangiumGrammarGrammar "elements": [ { "$type": "Action", - "inferredType": { - "$type": "InferredType", - "name": "Group" + "type": { + "$ref": "#/interfaces@33" }, "feature": "elements", "operator": "+=" @@ -1608,9 +1647,8 @@ export const LangiumGrammarGrammar = (): Grammar => loadedLangiumGrammarGrammar { "$type": "ParserRule", "name": "AbstractToken", - "inferredType": { - "$type": "InferredType", - "name": "AbstractElement" + "returnType": { + "$ref": "#/interfaces@0" }, "definition": { "$type": "Alternatives", @@ -1638,9 +1676,8 @@ export const LangiumGrammarGrammar = (): Grammar => loadedLangiumGrammarGrammar { "$type": "ParserRule", "name": "AbstractTokenWithCardinality", - "inferredType": { - "$type": "InferredType", - "name": "AbstractElement" + "returnType": { + "$ref": "#/interfaces@0" }, "definition": { "$type": "Group", @@ -1696,18 +1733,16 @@ export const LangiumGrammarGrammar = (): Grammar => loadedLangiumGrammarGrammar { "$type": "ParserRule", "name": "Action", - "inferredType": { - "$type": "InferredType", - "name": "AbstractElement" + "returnType": { + "$ref": "#/interfaces@0" }, "definition": { "$type": "Group", "elements": [ { "$type": "Action", - "inferredType": { - "$type": "InferredType", - "name": "Action" + "type": { + "$ref": "#/interfaces@27" } }, { @@ -1724,7 +1759,7 @@ export const LangiumGrammarGrammar = (): Grammar => loadedLangiumGrammarGrammar "terminal": { "$type": "CrossReference", "type": { - "$ref": "#/types@0" + "$ref": "#/types@1" }, "terminal": { "$type": "RuleCall", @@ -1816,9 +1851,8 @@ export const LangiumGrammarGrammar = (): Grammar => loadedLangiumGrammarGrammar { "$type": "ParserRule", "name": "AbstractTerminal", - "inferredType": { - "$type": "InferredType", - "name": "AbstractElement" + "returnType": { + "$ref": "#/interfaces@0" }, "definition": { "$type": "Alternatives", @@ -1881,14 +1915,16 @@ export const LangiumGrammarGrammar = (): Grammar => loadedLangiumGrammarGrammar { "$type": "ParserRule", "name": "EndOfFile", + "returnType": { + "$ref": "#/interfaces@32" + }, "definition": { "$type": "Group", "elements": [ { "$type": "Action", - "inferredType": { - "$type": "InferredType", - "name": "EndOfFile" + "type": { + "$ref": "#/interfaces@32" } }, { @@ -1904,6 +1940,9 @@ export const LangiumGrammarGrammar = (): Grammar => loadedLangiumGrammarGrammar { "$type": "ParserRule", "name": "Keyword", + "returnType": { + "$ref": "#/interfaces@34" + }, "definition": { "$type": "Assignment", "feature": "value", @@ -1923,6 +1962,9 @@ export const LangiumGrammarGrammar = (): Grammar => loadedLangiumGrammarGrammar { "$type": "ParserRule", "name": "RuleCall", + "returnType": { + "$ref": "#/interfaces@37" + }, "definition": { "$type": "Group", "elements": [ @@ -1933,7 +1975,7 @@ export const LangiumGrammarGrammar = (): Grammar => loadedLangiumGrammarGrammar "terminal": { "$type": "CrossReference", "type": { - "$ref": "#/rules@15" + "$ref": "#/types@0" }, "terminal": { "$type": "RuleCall", @@ -2002,6 +2044,9 @@ export const LangiumGrammarGrammar = (): Grammar => loadedLangiumGrammarGrammar { "$type": "ParserRule", "name": "NamedArgument", + "returnType": { + "$ref": "#/interfaces@13" + }, "definition": { "$type": "Group", "elements": [ @@ -2015,7 +2060,7 @@ export const LangiumGrammarGrammar = (): Grammar => loadedLangiumGrammarGrammar "terminal": { "$type": "CrossReference", "type": { - "$ref": "#/rules@24" + "$ref": "#/interfaces@16" }, "terminal": { "$type": "RuleCall", @@ -2060,9 +2105,8 @@ export const LangiumGrammarGrammar = (): Grammar => loadedLangiumGrammarGrammar { "$type": "ParserRule", "name": "Disjunction", - "inferredType": { - "$type": "InferredType", - "name": "Condition" + "returnType": { + "$ref": "#/types@3" }, "definition": { "$type": "Group", @@ -2079,9 +2123,8 @@ export const LangiumGrammarGrammar = (): Grammar => loadedLangiumGrammarGrammar "elements": [ { "$type": "Action", - "inferredType": { - "$type": "InferredType", - "name": "Disjunction" + "type": { + "$ref": "#/interfaces@5" }, "feature": "left", "operator": "=" @@ -2114,9 +2157,8 @@ export const LangiumGrammarGrammar = (): Grammar => loadedLangiumGrammarGrammar { "$type": "ParserRule", "name": "Conjunction", - "inferredType": { - "$type": "InferredType", - "name": "Condition" + "returnType": { + "$ref": "#/types@3" }, "definition": { "$type": "Group", @@ -2133,9 +2175,8 @@ export const LangiumGrammarGrammar = (): Grammar => loadedLangiumGrammarGrammar "elements": [ { "$type": "Action", - "inferredType": { - "$type": "InferredType", - "name": "Conjunction" + "type": { + "$ref": "#/interfaces@4" }, "feature": "left", "operator": "=" @@ -2168,9 +2209,8 @@ export const LangiumGrammarGrammar = (): Grammar => loadedLangiumGrammarGrammar { "$type": "ParserRule", "name": "Negation", - "inferredType": { - "$type": "InferredType", - "name": "Condition" + "returnType": { + "$ref": "#/types@3" }, "definition": { "$type": "Alternatives", @@ -2187,9 +2227,8 @@ export const LangiumGrammarGrammar = (): Grammar => loadedLangiumGrammarGrammar "elements": [ { "$type": "Action", - "inferredType": { - "$type": "InferredType", - "name": "Negation" + "type": { + "$ref": "#/interfaces@14" } }, { @@ -2219,9 +2258,8 @@ export const LangiumGrammarGrammar = (): Grammar => loadedLangiumGrammarGrammar { "$type": "ParserRule", "name": "Atom", - "inferredType": { - "$type": "InferredType", - "name": "Condition" + "returnType": { + "$ref": "#/types@3" }, "definition": { "$type": "Alternatives", @@ -2256,9 +2294,8 @@ export const LangiumGrammarGrammar = (): Grammar => loadedLangiumGrammarGrammar { "$type": "ParserRule", "name": "ParenthesizedCondition", - "inferredType": { - "$type": "InferredType", - "name": "Condition" + "returnType": { + "$ref": "#/types@3" }, "definition": { "$type": "Group", @@ -2287,6 +2324,9 @@ export const LangiumGrammarGrammar = (): Grammar => loadedLangiumGrammarGrammar { "$type": "ParserRule", "name": "ParameterReference", + "returnType": { + "$ref": "#/interfaces@17" + }, "definition": { "$type": "Assignment", "feature": "parameter", @@ -2294,7 +2334,7 @@ export const LangiumGrammarGrammar = (): Grammar => loadedLangiumGrammarGrammar "terminal": { "$type": "CrossReference", "type": { - "$ref": "#/rules@24" + "$ref": "#/interfaces@16" }, "terminal": { "$type": "RuleCall", @@ -2313,9 +2353,8 @@ export const LangiumGrammarGrammar = (): Grammar => loadedLangiumGrammarGrammar { "$type": "ParserRule", "name": "PredicatedKeyword", - "inferredType": { - "$type": "InferredType", - "name": "Keyword" + "returnType": { + "$ref": "#/interfaces@34" }, "definition": { "$type": "Group", @@ -2359,9 +2398,8 @@ export const LangiumGrammarGrammar = (): Grammar => loadedLangiumGrammarGrammar { "$type": "ParserRule", "name": "PredicatedRuleCall", - "inferredType": { - "$type": "InferredType", - "name": "RuleCall" + "returnType": { + "$ref": "#/interfaces@37" }, "definition": { "$type": "Group", @@ -2391,7 +2429,7 @@ export const LangiumGrammarGrammar = (): Grammar => loadedLangiumGrammarGrammar "terminal": { "$type": "CrossReference", "type": { - "$ref": "#/rules@15" + "$ref": "#/types@0" }, "terminal": { "$type": "RuleCall", @@ -2460,18 +2498,16 @@ export const LangiumGrammarGrammar = (): Grammar => loadedLangiumGrammarGrammar { "$type": "ParserRule", "name": "Assignment", - "inferredType": { - "$type": "InferredType", - "name": "AbstractElement" + "returnType": { + "$ref": "#/interfaces@0" }, "definition": { "$type": "Group", "elements": [ { "$type": "Action", - "inferredType": { - "$type": "InferredType", - "name": "Assignment" + "type": { + "$ref": "#/interfaces@29" } }, { @@ -2548,9 +2584,8 @@ export const LangiumGrammarGrammar = (): Grammar => loadedLangiumGrammarGrammar { "$type": "ParserRule", "name": "AssignableTerminal", - "inferredType": { - "$type": "InferredType", - "name": "AbstractElement" + "returnType": { + "$ref": "#/interfaces@0" }, "definition": { "$type": "Alternatives", @@ -2592,9 +2627,8 @@ export const LangiumGrammarGrammar = (): Grammar => loadedLangiumGrammarGrammar { "$type": "ParserRule", "name": "ParenthesizedAssignableElement", - "inferredType": { - "$type": "InferredType", - "name": "AbstractElement" + "returnType": { + "$ref": "#/interfaces@0" }, "definition": { "$type": "Group", @@ -2623,9 +2657,8 @@ export const LangiumGrammarGrammar = (): Grammar => loadedLangiumGrammarGrammar { "$type": "ParserRule", "name": "AssignableAlternatives", - "inferredType": { - "$type": "InferredType", - "name": "AbstractElement" + "returnType": { + "$ref": "#/interfaces@0" }, "definition": { "$type": "Group", @@ -2642,9 +2675,8 @@ export const LangiumGrammarGrammar = (): Grammar => loadedLangiumGrammarGrammar "elements": [ { "$type": "Action", - "inferredType": { - "$type": "InferredType", - "name": "Alternatives" + "type": { + "$ref": "#/interfaces@28" }, "feature": "elements", "operator": "+=" @@ -2683,18 +2715,16 @@ export const LangiumGrammarGrammar = (): Grammar => loadedLangiumGrammarGrammar { "$type": "ParserRule", "name": "CrossReference", - "inferredType": { - "$type": "InferredType", - "name": "AbstractElement" + "returnType": { + "$ref": "#/interfaces@0" }, "definition": { "$type": "Group", "elements": [ { "$type": "Action", - "inferredType": { - "$type": "InferredType", - "name": "CrossReference" + "type": { + "$ref": "#/interfaces@31" } }, { @@ -2708,7 +2738,14 @@ export const LangiumGrammarGrammar = (): Grammar => loadedLangiumGrammarGrammar "terminal": { "$type": "CrossReference", "type": { - "$ref": "#/types@0" + "$ref": "#/types@1" + }, + "terminal": { + "$type": "RuleCall", + "rule": { + "$ref": "#/rules@67" + }, + "arguments": [] }, "deprecatedSyntax": false } @@ -2762,9 +2799,8 @@ export const LangiumGrammarGrammar = (): Grammar => loadedLangiumGrammarGrammar { "$type": "ParserRule", "name": "CrossReferenceableTerminal", - "inferredType": { - "$type": "InferredType", - "name": "AbstractElement" + "returnType": { + "$ref": "#/interfaces@0" }, "definition": { "$type": "Alternatives", @@ -2792,9 +2828,8 @@ export const LangiumGrammarGrammar = (): Grammar => loadedLangiumGrammarGrammar { "$type": "ParserRule", "name": "ParenthesizedElement", - "inferredType": { - "$type": "InferredType", - "name": "AbstractElement" + "returnType": { + "$ref": "#/interfaces@0" }, "definition": { "$type": "Group", @@ -2823,9 +2858,8 @@ export const LangiumGrammarGrammar = (): Grammar => loadedLangiumGrammarGrammar { "$type": "ParserRule", "name": "PredicatedGroup", - "inferredType": { - "$type": "InferredType", - "name": "Group" + "returnType": { + "$ref": "#/interfaces@33" }, "definition": { "$type": "Group", @@ -2877,6 +2911,9 @@ export const LangiumGrammarGrammar = (): Grammar => loadedLangiumGrammarGrammar { "$type": "ParserRule", "name": "ReturnType", + "returnType": { + "$ref": "#/interfaces@20" + }, "definition": { "$type": "Assignment", "feature": "name", @@ -2908,6 +2945,9 @@ export const LangiumGrammarGrammar = (): Grammar => loadedLangiumGrammarGrammar { "$type": "ParserRule", "name": "TerminalRule", + "returnType": { + "$ref": "#/interfaces@23" + }, "definition": { "$type": "Group", "elements": [ @@ -3024,9 +3064,8 @@ export const LangiumGrammarGrammar = (): Grammar => loadedLangiumGrammarGrammar { "$type": "ParserRule", "name": "TerminalAlternatives", - "inferredType": { - "$type": "InferredType", - "name": "AbstractElement" + "returnType": { + "$ref": "#/interfaces@39" }, "definition": { "$type": "Group", @@ -3043,9 +3082,8 @@ export const LangiumGrammarGrammar = (): Grammar => loadedLangiumGrammarGrammar "elements": [ { "$type": "Action", - "inferredType": { - "$type": "InferredType", - "name": "TerminalAlternatives" + "type": { + "$ref": "#/interfaces@38" }, "feature": "elements", "operator": "+=" @@ -3078,9 +3116,8 @@ export const LangiumGrammarGrammar = (): Grammar => loadedLangiumGrammarGrammar { "$type": "ParserRule", "name": "TerminalGroup", - "inferredType": { - "$type": "InferredType", - "name": "AbstractElement" + "returnType": { + "$ref": "#/interfaces@39" }, "definition": { "$type": "Group", @@ -3097,9 +3134,8 @@ export const LangiumGrammarGrammar = (): Grammar => loadedLangiumGrammarGrammar "elements": [ { "$type": "Action", - "inferredType": { - "$type": "InferredType", - "name": "TerminalGroup" + "type": { + "$ref": "#/interfaces@40" }, "feature": "elements", "operator": "+=" @@ -3129,9 +3165,8 @@ export const LangiumGrammarGrammar = (): Grammar => loadedLangiumGrammarGrammar { "$type": "ParserRule", "name": "TerminalToken", - "inferredType": { - "$type": "InferredType", - "name": "AbstractElement" + "returnType": { + "$ref": "#/interfaces@39" }, "definition": { "$type": "Group", @@ -3175,9 +3210,8 @@ export const LangiumGrammarGrammar = (): Grammar => loadedLangiumGrammarGrammar { "$type": "ParserRule", "name": "TerminalTokenElement", - "inferredType": { - "$type": "InferredType", - "name": "AbstractElement" + "returnType": { + "$ref": "#/interfaces@39" }, "definition": { "$type": "Alternatives", @@ -3240,9 +3274,8 @@ export const LangiumGrammarGrammar = (): Grammar => loadedLangiumGrammarGrammar { "$type": "ParserRule", "name": "ParenthesizedTerminalElement", - "inferredType": { - "$type": "InferredType", - "name": "AbstractElement" + "returnType": { + "$ref": "#/interfaces@39" }, "definition": { "$type": "Group", @@ -3286,8 +3319,13 @@ export const LangiumGrammarGrammar = (): Grammar => loadedLangiumGrammarGrammar "arguments": [] }, { - "$type": "Keyword", - "value": ")" + "$type": "Assignment", + "feature": "parenthesized", + "operator": "?=", + "terminal": { + "$type": "Keyword", + "value": ")" + } } ] }, @@ -3298,18 +3336,16 @@ export const LangiumGrammarGrammar = (): Grammar => loadedLangiumGrammarGrammar { "$type": "ParserRule", "name": "TerminalRuleCall", - "inferredType": { - "$type": "InferredType", - "name": "AbstractElement" + "returnType": { + "$ref": "#/interfaces@39" }, "definition": { "$type": "Group", "elements": [ { "$type": "Action", - "inferredType": { - "$type": "InferredType", - "name": "TerminalRuleCall" + "type": { + "$ref": "#/interfaces@41" } }, { @@ -3319,7 +3355,7 @@ export const LangiumGrammarGrammar = (): Grammar => loadedLangiumGrammarGrammar "terminal": { "$type": "CrossReference", "type": { - "$ref": "#/rules@54" + "$ref": "#/interfaces@23" }, "terminal": { "$type": "RuleCall", @@ -3340,18 +3376,16 @@ export const LangiumGrammarGrammar = (): Grammar => loadedLangiumGrammarGrammar { "$type": "ParserRule", "name": "NegatedToken", - "inferredType": { - "$type": "InferredType", - "name": "AbstractElement" + "returnType": { + "$ref": "#/interfaces@39" }, "definition": { "$type": "Group", "elements": [ { "$type": "Action", - "inferredType": { - "$type": "InferredType", - "name": "NegatedToken" + "type": { + "$ref": "#/interfaces@35" } }, { @@ -3379,18 +3413,16 @@ export const LangiumGrammarGrammar = (): Grammar => loadedLangiumGrammarGrammar { "$type": "ParserRule", "name": "UntilToken", - "inferredType": { - "$type": "InferredType", - "name": "AbstractElement" + "returnType": { + "$ref": "#/interfaces@39" }, "definition": { "$type": "Group", "elements": [ { "$type": "Action", - "inferredType": { - "$type": "InferredType", - "name": "UntilToken" + "type": { + "$ref": "#/interfaces@43" } }, { @@ -3418,18 +3450,16 @@ export const LangiumGrammarGrammar = (): Grammar => loadedLangiumGrammarGrammar { "$type": "ParserRule", "name": "RegexToken", - "inferredType": { - "$type": "InferredType", - "name": "AbstractElement" + "returnType": { + "$ref": "#/interfaces@39" }, "definition": { "$type": "Group", "elements": [ { "$type": "Action", - "inferredType": { - "$type": "InferredType", - "name": "RegexToken" + "type": { + "$ref": "#/interfaces@36" } }, { @@ -3453,18 +3483,16 @@ export const LangiumGrammarGrammar = (): Grammar => loadedLangiumGrammarGrammar { "$type": "ParserRule", "name": "Wildcard", - "inferredType": { - "$type": "InferredType", - "name": "AbstractElement" + "returnType": { + "$ref": "#/interfaces@39" }, "definition": { "$type": "Group", "elements": [ { "$type": "Action", - "inferredType": { - "$type": "InferredType", - "name": "Wildcard" + "type": { + "$ref": "#/interfaces@44" } }, { @@ -3480,18 +3508,16 @@ export const LangiumGrammarGrammar = (): Grammar => loadedLangiumGrammarGrammar { "$type": "ParserRule", "name": "CharacterRange", - "inferredType": { - "$type": "InferredType", - "name": "AbstractElement" + "returnType": { + "$ref": "#/interfaces@39" }, "definition": { "$type": "Group", "elements": [ { "$type": "Action", - "inferredType": { - "$type": "InferredType", - "name": "CharacterRange" + "type": { + "$ref": "#/interfaces@30" } }, { @@ -3650,7 +3676,8 @@ export const LangiumGrammarGrammar = (): Grammar => loadedLangiumGrammarGrammar "name": "ID", "definition": { "$type": "RegexToken", - "regex": "/\\\\^?[_a-zA-Z][\\\\w_]*/" + "regex": "/\\\\^?[_a-zA-Z][\\\\w_]*/", + "parenthesized": false }, "fragment": false, "hidden": false @@ -3660,7 +3687,8 @@ export const LangiumGrammarGrammar = (): Grammar => loadedLangiumGrammarGrammar "name": "STRING", "definition": { "$type": "RegexToken", - "regex": "/\\"(\\\\\\\\.|[^\\"\\\\\\\\])*\\"|'(\\\\\\\\.|[^'\\\\\\\\])*'/" + "regex": "/\\"(\\\\\\\\.|[^\\"\\\\\\\\])*\\"|'(\\\\\\\\.|[^'\\\\\\\\])*'/", + "parenthesized": false }, "fragment": false, "hidden": false @@ -3674,7 +3702,8 @@ export const LangiumGrammarGrammar = (): Grammar => loadedLangiumGrammarGrammar }, "definition": { "$type": "RegexToken", - "regex": "/NaN|-?((\\\\d*\\\\.\\\\d+|\\\\d+)([Ee][+-]?\\\\d+)?|Infinity)/" + "regex": "/NaN|-?((\\\\d*\\\\.\\\\d+|\\\\d+)([Ee][+-]?\\\\d+)?|Infinity)/", + "parenthesized": false }, "fragment": false, "hidden": false @@ -3688,7 +3717,8 @@ export const LangiumGrammarGrammar = (): Grammar => loadedLangiumGrammarGrammar }, "definition": { "$type": "RegexToken", - "regex": "/\\\\/(?![*+?])(?:[^\\\\r\\\\n\\\\[/\\\\\\\\]|\\\\\\\\.|\\\\[(?:[^\\\\r\\\\n\\\\]\\\\\\\\]|\\\\\\\\.)*\\\\])+\\\\/[a-z]*/" + "regex": "/\\\\/(?![*+?])(?:[^\\\\r\\\\n\\\\[/\\\\\\\\]|\\\\\\\\.|\\\\[(?:[^\\\\r\\\\n\\\\]\\\\\\\\]|\\\\\\\\.)*\\\\])+\\\\/[a-z]*/", + "parenthesized": false }, "fragment": false, "hidden": false @@ -3699,7 +3729,8 @@ export const LangiumGrammarGrammar = (): Grammar => loadedLangiumGrammarGrammar "name": "WS", "definition": { "$type": "RegexToken", - "regex": "/\\\\s+/" + "regex": "/\\\\s+/", + "parenthesized": false }, "fragment": false }, @@ -3709,7 +3740,8 @@ export const LangiumGrammarGrammar = (): Grammar => loadedLangiumGrammarGrammar "name": "ML_COMMENT", "definition": { "$type": "RegexToken", - "regex": "/\\\\/\\\\*[\\\\s\\\\S]*?\\\\*\\\\//" + "regex": "/\\\\/\\\\*[\\\\s\\\\S]*?\\\\*\\\\//", + "parenthesized": false }, "fragment": false }, @@ -3719,52 +3751,1823 @@ export const LangiumGrammarGrammar = (): Grammar => loadedLangiumGrammarGrammar "name": "SL_COMMENT", "definition": { "$type": "RegexToken", - "regex": "/\\\\/\\\\/[^\\\\n\\\\r]*/" + "regex": "/\\\\/\\\\/[^\\\\n\\\\r]*/", + "parenthesized": false }, "fragment": false } ], - "types": [ + "interfaces": [ { - "$type": "Type", - "name": "AbstractType", - "type": { - "$type": "UnionType", - "types": [ - { + "$type": "Interface", + "name": "AbstractElement", + "attributes": [ + { + "$type": "TypeAttribute", + "name": "cardinality", + "isOptional": true, + "type": { + "$type": "UnionType", + "types": [ + { + "$type": "SimpleType", + "stringType": "*" + }, + { + "$type": "SimpleType", + "stringType": "+" + }, + { + "$type": "SimpleType", + "stringType": "?" + } + ] + } + } + ], + "superTypes": [] + }, + { + "$type": "Interface", + "name": "ArrayLiteral", + "attributes": [ + { + "$type": "TypeAttribute", + "name": "elements", + "type": { + "$type": "ArrayType", + "elementType": { + "$type": "SimpleType", + "typeRef": { + "$ref": "#/types@7" + } + } + }, + "isOptional": false + } + ], + "superTypes": [] + }, + { + "$type": "Interface", + "name": "ArrayType", + "attributes": [ + { + "$type": "TypeAttribute", + "name": "elementType", + "type": { "$type": "SimpleType", "typeRef": { - "$ref": "#/rules@1" + "$ref": "#/types@6" } }, - { + "isOptional": false + } + ], + "superTypes": [] + }, + { + "$type": "Interface", + "name": "BooleanLiteral", + "attributes": [ + { + "$type": "TypeAttribute", + "name": "true", + "type": { + "$type": "SimpleType", + "primitiveType": "boolean" + }, + "isOptional": false + } + ], + "superTypes": [] + }, + { + "$type": "Interface", + "name": "Conjunction", + "attributes": [ + { + "$type": "TypeAttribute", + "name": "left", + "type": { "$type": "SimpleType", "typeRef": { - "$ref": "#/rules@14" + "$ref": "#/types@3" } }, - { + "isOptional": false + }, + { + "$type": "TypeAttribute", + "name": "right", + "type": { "$type": "SimpleType", "typeRef": { - "$ref": "#/rules@17" + "$ref": "#/types@3" } }, - { + "isOptional": false + } + ], + "superTypes": [] + }, + { + "$type": "Interface", + "name": "Disjunction", + "attributes": [ + { + "$type": "TypeAttribute", + "name": "left", + "type": { "$type": "SimpleType", "typeRef": { - "$ref": "#/rules@18" + "$ref": "#/types@3" } }, - { + "isOptional": false + }, + { + "$type": "TypeAttribute", + "name": "right", + "type": { + "$type": "SimpleType", + "typeRef": { + "$ref": "#/types@3" + } + }, + "isOptional": false + } + ], + "superTypes": [] + }, + { + "$type": "Interface", + "name": "Grammar", + "attributes": [ + { + "$type": "TypeAttribute", + "name": "imports", + "type": { + "$type": "ArrayType", + "elementType": { + "$type": "SimpleType", + "typeRef": { + "$ref": "#/interfaces@7" + } + } + }, + "isOptional": false + }, + { + "$type": "TypeAttribute", + "name": "interfaces", + "type": { + "$type": "ArrayType", + "elementType": { + "$type": "SimpleType", + "typeRef": { + "$ref": "#/interfaces@12" + } + } + }, + "isOptional": false + }, + { + "$type": "TypeAttribute", + "name": "isDeclared", + "type": { + "$type": "SimpleType", + "primitiveType": "boolean" + }, + "isOptional": false + }, + { + "$type": "TypeAttribute", + "name": "name", + "isOptional": true, + "type": { + "$type": "SimpleType", + "primitiveType": "string" + } + }, + { + "$type": "TypeAttribute", + "name": "rules", + "type": { + "$type": "ArrayType", + "elementType": { + "$type": "SimpleType", + "typeRef": { + "$ref": "#/types@0" + } + } + }, + "isOptional": false + }, + { + "$type": "TypeAttribute", + "name": "types", + "type": { + "$type": "ArrayType", + "elementType": { + "$type": "SimpleType", + "typeRef": { + "$ref": "#/interfaces@24" + } + } + }, + "isOptional": false + } + ], + "superTypes": [] + }, + { + "$type": "Interface", + "name": "GrammarImport", + "attributes": [ + { + "$type": "TypeAttribute", + "name": "path", + "type": { + "$type": "SimpleType", + "primitiveType": "string" + }, + "isOptional": false + } + ], + "superTypes": [] + }, + { + "$type": "Interface", + "name": "InferredType", + "attributes": [ + { + "$type": "TypeAttribute", + "name": "name", + "type": { + "$type": "SimpleType", + "primitiveType": "string" + }, + "isOptional": false + } + ], + "superTypes": [] + }, + { + "$type": "Interface", + "name": "InfixRule", + "attributes": [ + { + "$type": "TypeAttribute", + "name": "call", + "type": { + "$type": "SimpleType", + "typeRef": { + "$ref": "#/interfaces@37" + } + }, + "isOptional": false + }, + { + "$type": "TypeAttribute", + "name": "name", + "type": { + "$type": "SimpleType", + "primitiveType": "string" + }, + "isOptional": false + }, + { + "$type": "TypeAttribute", + "name": "operators", + "type": { "$type": "SimpleType", "typeRef": { - "$ref": "#/rules@22" + "$ref": "#/interfaces@11" + } + }, + "isOptional": false + }, + { + "$type": "TypeAttribute", + "name": "parameters", + "type": { + "$type": "ArrayType", + "elementType": { + "$type": "SimpleType", + "typeRef": { + "$ref": "#/interfaces@16" + } + } + }, + "isOptional": false + } + ], + "superTypes": [] + }, + { + "$type": "Interface", + "name": "InfixRuleOperatorList", + "attributes": [ + { + "$type": "TypeAttribute", + "name": "associativity", + "isOptional": true, + "type": { + "$type": "SimpleType", + "typeRef": { + "$ref": "#/types@2" } } - ] - } - } - ], - "imports": [], - "interfaces": [] + }, + { + "$type": "TypeAttribute", + "name": "operators", + "type": { + "$type": "ArrayType", + "elementType": { + "$type": "SimpleType", + "typeRef": { + "$ref": "#/interfaces@34" + } + } + }, + "isOptional": false + } + ], + "superTypes": [] + }, + { + "$type": "Interface", + "name": "InfixRuleOperators", + "attributes": [ + { + "$type": "TypeAttribute", + "name": "precedences", + "type": { + "$type": "ArrayType", + "elementType": { + "$type": "SimpleType", + "typeRef": { + "$ref": "#/interfaces@10" + } + } + }, + "isOptional": false + } + ], + "superTypes": [] + }, + { + "$type": "Interface", + "name": "Interface", + "attributes": [ + { + "$type": "TypeAttribute", + "name": "attributes", + "type": { + "$type": "ArrayType", + "elementType": { + "$type": "SimpleType", + "typeRef": { + "$ref": "#/interfaces@25" + } + } + }, + "isOptional": false + }, + { + "$type": "TypeAttribute", + "name": "name", + "type": { + "$type": "SimpleType", + "primitiveType": "string" + }, + "isOptional": false + }, + { + "$type": "TypeAttribute", + "name": "superTypes", + "type": { + "$type": "ArrayType", + "elementType": { + "$type": "ReferenceType", + "referenceType": { + "$type": "SimpleType", + "typeRef": { + "$ref": "#/types@1" + } + } + } + }, + "isOptional": false + } + ], + "superTypes": [] + }, + { + "$type": "Interface", + "name": "NamedArgument", + "attributes": [ + { + "$type": "TypeAttribute", + "name": "calledByName", + "type": { + "$type": "SimpleType", + "primitiveType": "boolean" + }, + "isOptional": false + }, + { + "$type": "TypeAttribute", + "name": "parameter", + "isOptional": true, + "type": { + "$type": "ReferenceType", + "referenceType": { + "$type": "SimpleType", + "typeRef": { + "$ref": "#/interfaces@16" + } + } + } + }, + { + "$type": "TypeAttribute", + "name": "value", + "type": { + "$type": "SimpleType", + "typeRef": { + "$ref": "#/types@3" + } + }, + "isOptional": false + } + ], + "superTypes": [] + }, + { + "$type": "Interface", + "name": "Negation", + "attributes": [ + { + "$type": "TypeAttribute", + "name": "value", + "type": { + "$type": "SimpleType", + "typeRef": { + "$ref": "#/types@3" + } + }, + "isOptional": false + } + ], + "superTypes": [] + }, + { + "$type": "Interface", + "name": "NumberLiteral", + "attributes": [ + { + "$type": "TypeAttribute", + "name": "value", + "type": { + "$type": "SimpleType", + "primitiveType": "number" + }, + "isOptional": false + } + ], + "superTypes": [] + }, + { + "$type": "Interface", + "name": "Parameter", + "attributes": [ + { + "$type": "TypeAttribute", + "name": "name", + "type": { + "$type": "SimpleType", + "primitiveType": "string" + }, + "isOptional": false + } + ], + "superTypes": [] + }, + { + "$type": "Interface", + "name": "ParameterReference", + "attributes": [ + { + "$type": "TypeAttribute", + "name": "parameter", + "type": { + "$type": "ReferenceType", + "referenceType": { + "$type": "SimpleType", + "typeRef": { + "$ref": "#/interfaces@16" + } + } + }, + "isOptional": false + } + ], + "superTypes": [] + }, + { + "$type": "Interface", + "name": "ParserRule", + "attributes": [ + { + "$type": "TypeAttribute", + "name": "dataType", + "isOptional": true, + "type": { + "$type": "SimpleType", + "typeRef": { + "$ref": "#/types@5" + } + } + }, + { + "$type": "TypeAttribute", + "name": "definition", + "type": { + "$type": "SimpleType", + "typeRef": { + "$ref": "#/interfaces@0" + } + }, + "isOptional": false + }, + { + "$type": "TypeAttribute", + "name": "entry", + "type": { + "$type": "SimpleType", + "primitiveType": "boolean" + }, + "isOptional": false + }, + { + "$type": "TypeAttribute", + "name": "fragment", + "type": { + "$type": "SimpleType", + "primitiveType": "boolean" + }, + "isOptional": false + }, + { + "$type": "TypeAttribute", + "name": "inferredType", + "isOptional": true, + "type": { + "$type": "SimpleType", + "typeRef": { + "$ref": "#/interfaces@8" + } + } + }, + { + "$type": "TypeAttribute", + "name": "name", + "type": { + "$type": "SimpleType", + "primitiveType": "string" + }, + "isOptional": false + }, + { + "$type": "TypeAttribute", + "name": "parameters", + "type": { + "$type": "ArrayType", + "elementType": { + "$type": "SimpleType", + "typeRef": { + "$ref": "#/interfaces@16" + } + } + }, + "isOptional": false + }, + { + "$type": "TypeAttribute", + "name": "returnType", + "isOptional": true, + "type": { + "$type": "ReferenceType", + "referenceType": { + "$type": "SimpleType", + "typeRef": { + "$ref": "#/types@1" + } + } + } + } + ], + "superTypes": [] + }, + { + "$type": "Interface", + "name": "ReferenceType", + "attributes": [ + { + "$type": "TypeAttribute", + "name": "referenceType", + "type": { + "$type": "SimpleType", + "typeRef": { + "$ref": "#/types@6" + } + }, + "isOptional": false + } + ], + "superTypes": [] + }, + { + "$type": "Interface", + "name": "ReturnType", + "attributes": [ + { + "$type": "TypeAttribute", + "name": "name", + "type": { + "$type": "UnionType", + "types": [ + { + "$type": "SimpleType", + "typeRef": { + "$ref": "#/types@5" + } + }, + { + "$type": "SimpleType", + "primitiveType": "string" + } + ] + }, + "isOptional": false + } + ], + "superTypes": [] + }, + { + "$type": "Interface", + "name": "SimpleType", + "attributes": [ + { + "$type": "TypeAttribute", + "name": "primitiveType", + "isOptional": true, + "type": { + "$type": "SimpleType", + "typeRef": { + "$ref": "#/types@5" + } + } + }, + { + "$type": "TypeAttribute", + "name": "stringType", + "isOptional": true, + "type": { + "$type": "SimpleType", + "primitiveType": "string" + } + }, + { + "$type": "TypeAttribute", + "name": "typeRef", + "isOptional": true, + "type": { + "$type": "ReferenceType", + "referenceType": { + "$type": "SimpleType", + "typeRef": { + "$ref": "#/types@1" + } + } + } + } + ], + "superTypes": [] + }, + { + "$type": "Interface", + "name": "StringLiteral", + "attributes": [ + { + "$type": "TypeAttribute", + "name": "value", + "type": { + "$type": "SimpleType", + "primitiveType": "string" + }, + "isOptional": false + } + ], + "superTypes": [] + }, + { + "$type": "Interface", + "name": "TerminalRule", + "attributes": [ + { + "$type": "TypeAttribute", + "name": "definition", + "type": { + "$type": "SimpleType", + "typeRef": { + "$ref": "#/interfaces@39" + } + }, + "isOptional": false + }, + { + "$type": "TypeAttribute", + "name": "fragment", + "type": { + "$type": "SimpleType", + "primitiveType": "boolean" + }, + "isOptional": false + }, + { + "$type": "TypeAttribute", + "name": "hidden", + "type": { + "$type": "SimpleType", + "primitiveType": "boolean" + }, + "isOptional": false + }, + { + "$type": "TypeAttribute", + "name": "name", + "type": { + "$type": "SimpleType", + "primitiveType": "string" + }, + "isOptional": false + }, + { + "$type": "TypeAttribute", + "name": "type", + "isOptional": true, + "type": { + "$type": "SimpleType", + "typeRef": { + "$ref": "#/interfaces@20" + } + } + } + ], + "superTypes": [] + }, + { + "$type": "Interface", + "name": "Type", + "attributes": [ + { + "$type": "TypeAttribute", + "name": "name", + "type": { + "$type": "SimpleType", + "primitiveType": "string" + }, + "isOptional": false + }, + { + "$type": "TypeAttribute", + "name": "type", + "type": { + "$type": "SimpleType", + "typeRef": { + "$ref": "#/types@6" + } + }, + "isOptional": false + } + ], + "superTypes": [] + }, + { + "$type": "Interface", + "name": "TypeAttribute", + "attributes": [ + { + "$type": "TypeAttribute", + "name": "defaultValue", + "isOptional": true, + "type": { + "$type": "SimpleType", + "typeRef": { + "$ref": "#/types@7" + } + } + }, + { + "$type": "TypeAttribute", + "name": "isOptional", + "type": { + "$type": "SimpleType", + "primitiveType": "boolean" + }, + "isOptional": false + }, + { + "$type": "TypeAttribute", + "name": "name", + "type": { + "$type": "SimpleType", + "typeRef": { + "$ref": "#/types@4" + } + }, + "isOptional": false + }, + { + "$type": "TypeAttribute", + "name": "type", + "type": { + "$type": "SimpleType", + "typeRef": { + "$ref": "#/types@6" + } + }, + "isOptional": false + } + ], + "superTypes": [] + }, + { + "$type": "Interface", + "name": "UnionType", + "attributes": [ + { + "$type": "TypeAttribute", + "name": "types", + "type": { + "$type": "ArrayType", + "elementType": { + "$type": "SimpleType", + "typeRef": { + "$ref": "#/types@6" + } + } + }, + "isOptional": false + } + ], + "superTypes": [] + }, + { + "$type": "Interface", + "name": "Action", + "superTypes": [ + { + "$ref": "#/interfaces@0" + } + ], + "attributes": [ + { + "$type": "TypeAttribute", + "name": "feature", + "isOptional": true, + "type": { + "$type": "SimpleType", + "typeRef": { + "$ref": "#/types@4" + } + } + }, + { + "$type": "TypeAttribute", + "name": "inferredType", + "isOptional": true, + "type": { + "$type": "SimpleType", + "typeRef": { + "$ref": "#/interfaces@8" + } + } + }, + { + "$type": "TypeAttribute", + "name": "operator", + "isOptional": true, + "type": { + "$type": "UnionType", + "types": [ + { + "$type": "SimpleType", + "stringType": "+=" + }, + { + "$type": "SimpleType", + "stringType": "=" + } + ] + } + }, + { + "$type": "TypeAttribute", + "name": "type", + "isOptional": true, + "type": { + "$type": "ReferenceType", + "referenceType": { + "$type": "SimpleType", + "typeRef": { + "$ref": "#/types@1" + } + } + } + } + ] + }, + { + "$type": "Interface", + "name": "Alternatives", + "superTypes": [ + { + "$ref": "#/interfaces@0" + } + ], + "attributes": [ + { + "$type": "TypeAttribute", + "name": "elements", + "type": { + "$type": "ArrayType", + "elementType": { + "$type": "SimpleType", + "typeRef": { + "$ref": "#/interfaces@0" + } + } + }, + "isOptional": false + } + ] + }, + { + "$type": "Interface", + "name": "Assignment", + "superTypes": [ + { + "$ref": "#/interfaces@0" + } + ], + "attributes": [ + { + "$type": "TypeAttribute", + "name": "feature", + "type": { + "$type": "SimpleType", + "typeRef": { + "$ref": "#/types@4" + } + }, + "isOptional": false + }, + { + "$type": "TypeAttribute", + "name": "operator", + "type": { + "$type": "UnionType", + "types": [ + { + "$type": "SimpleType", + "stringType": "+=" + }, + { + "$type": "SimpleType", + "stringType": "=" + }, + { + "$type": "SimpleType", + "stringType": "?=" + } + ] + }, + "isOptional": false + }, + { + "$type": "TypeAttribute", + "name": "predicate", + "isOptional": true, + "type": { + "$type": "UnionType", + "types": [ + { + "$type": "SimpleType", + "stringType": "->" + }, + { + "$type": "SimpleType", + "stringType": "=>" + } + ] + } + }, + { + "$type": "TypeAttribute", + "name": "terminal", + "type": { + "$type": "SimpleType", + "typeRef": { + "$ref": "#/interfaces@0" + } + }, + "isOptional": false + } + ] + }, + { + "$type": "Interface", + "name": "CharacterRange", + "superTypes": [ + { + "$ref": "#/interfaces@39" + } + ], + "attributes": [ + { + "$type": "TypeAttribute", + "name": "left", + "type": { + "$type": "SimpleType", + "typeRef": { + "$ref": "#/interfaces@34" + } + }, + "isOptional": false + }, + { + "$type": "TypeAttribute", + "name": "right", + "isOptional": true, + "type": { + "$type": "SimpleType", + "typeRef": { + "$ref": "#/interfaces@34" + } + } + } + ] + }, + { + "$type": "Interface", + "name": "CrossReference", + "superTypes": [ + { + "$ref": "#/interfaces@0" + } + ], + "attributes": [ + { + "$type": "TypeAttribute", + "name": "deprecatedSyntax", + "type": { + "$type": "SimpleType", + "primitiveType": "boolean" + }, + "isOptional": false + }, + { + "$type": "TypeAttribute", + "name": "terminal", + "isOptional": true, + "type": { + "$type": "SimpleType", + "typeRef": { + "$ref": "#/interfaces@0" + } + } + }, + { + "$type": "TypeAttribute", + "name": "type", + "type": { + "$type": "ReferenceType", + "referenceType": { + "$type": "SimpleType", + "typeRef": { + "$ref": "#/types@1" + } + } + }, + "isOptional": false + } + ] + }, + { + "$type": "Interface", + "name": "EndOfFile", + "superTypes": [ + { + "$ref": "#/interfaces@0" + } + ], + "attributes": [] + }, + { + "$type": "Interface", + "name": "Group", + "superTypes": [ + { + "$ref": "#/interfaces@0" + } + ], + "attributes": [ + { + "$type": "TypeAttribute", + "name": "elements", + "type": { + "$type": "ArrayType", + "elementType": { + "$type": "SimpleType", + "typeRef": { + "$ref": "#/interfaces@0" + } + } + }, + "isOptional": false + }, + { + "$type": "TypeAttribute", + "name": "guardCondition", + "isOptional": true, + "type": { + "$type": "SimpleType", + "typeRef": { + "$ref": "#/types@3" + } + } + }, + { + "$type": "TypeAttribute", + "name": "predicate", + "isOptional": true, + "type": { + "$type": "UnionType", + "types": [ + { + "$type": "SimpleType", + "stringType": "->" + }, + { + "$type": "SimpleType", + "stringType": "=>" + } + ] + } + } + ] + }, + { + "$type": "Interface", + "name": "Keyword", + "superTypes": [ + { + "$ref": "#/interfaces@0" + } + ], + "attributes": [ + { + "$type": "TypeAttribute", + "name": "predicate", + "isOptional": true, + "type": { + "$type": "UnionType", + "types": [ + { + "$type": "SimpleType", + "stringType": "->" + }, + { + "$type": "SimpleType", + "stringType": "=>" + } + ] + } + }, + { + "$type": "TypeAttribute", + "name": "value", + "type": { + "$type": "SimpleType", + "primitiveType": "string" + }, + "isOptional": false + } + ] + }, + { + "$type": "Interface", + "name": "NegatedToken", + "superTypes": [ + { + "$ref": "#/interfaces@39" + } + ], + "attributes": [ + { + "$type": "TypeAttribute", + "name": "terminal", + "type": { + "$type": "SimpleType", + "typeRef": { + "$ref": "#/interfaces@0" + } + }, + "isOptional": false + } + ] + }, + { + "$type": "Interface", + "name": "RegexToken", + "superTypes": [ + { + "$ref": "#/interfaces@39" + } + ], + "attributes": [ + { + "$type": "TypeAttribute", + "name": "regex", + "type": { + "$type": "SimpleType", + "primitiveType": "string" + }, + "isOptional": false + } + ] + }, + { + "$type": "Interface", + "name": "RuleCall", + "superTypes": [ + { + "$ref": "#/interfaces@0" + } + ], + "attributes": [ + { + "$type": "TypeAttribute", + "name": "arguments", + "type": { + "$type": "ArrayType", + "elementType": { + "$type": "SimpleType", + "typeRef": { + "$ref": "#/interfaces@13" + } + } + }, + "isOptional": false + }, + { + "$type": "TypeAttribute", + "name": "predicate", + "isOptional": true, + "type": { + "$type": "UnionType", + "types": [ + { + "$type": "SimpleType", + "stringType": "->" + }, + { + "$type": "SimpleType", + "stringType": "=>" + } + ] + } + }, + { + "$type": "TypeAttribute", + "name": "rule", + "type": { + "$type": "ReferenceType", + "referenceType": { + "$type": "SimpleType", + "typeRef": { + "$ref": "#/types@0" + } + } + }, + "isOptional": false + } + ] + }, + { + "$type": "Interface", + "name": "TerminalAlternatives", + "superTypes": [ + { + "$ref": "#/interfaces@39" + } + ], + "attributes": [ + { + "$type": "TypeAttribute", + "name": "elements", + "type": { + "$type": "ArrayType", + "elementType": { + "$type": "SimpleType", + "typeRef": { + "$ref": "#/interfaces@0" + } + } + }, + "isOptional": false + } + ] + }, + { + "$type": "Interface", + "name": "TerminalElement", + "superTypes": [ + { + "$ref": "#/interfaces@0" + } + ], + "attributes": [ + { + "$type": "TypeAttribute", + "name": "lookahead", + "isOptional": true, + "type": { + "$type": "UnionType", + "types": [ + { + "$type": "SimpleType", + "stringType": "?!" + }, + { + "$type": "SimpleType", + "stringType": "?)? ':' definition=Alternatives ';'; -InfixRule: 'infix' RuleNameAndParams 'on' call=RuleCall ':' operators=InfixRuleOperators ';'; +InfixRule returns InfixRule: 'infix' RuleNameAndParams 'on' call=RuleCall ':' operators=InfixRuleOperators ';'; -InfixRuleOperators: precedences+=InfixRuleOperatorList ('>' precedences+=InfixRuleOperatorList)*; +InfixRuleOperators returns InfixRuleOperators: precedences+=InfixRuleOperatorList ('>' precedences+=InfixRuleOperatorList)*; -InfixRuleOperatorList: +InfixRuleOperatorList returns InfixRuleOperatorList: (associativity=Associativity 'assoc')? operators+=Keyword ('|' operators+=Keyword)*; Associativity returns string: 'left' | 'right'; -InferredType: +InferredType returns InferredType: ( 'infer' | 'infers') name=ID; fragment RuleNameAndParams: name=ID ('<' (parameters+=Parameter (',' parameters+=Parameter)*)? '>')?; -Parameter: +Parameter returns Parameter: name=ID; -Alternatives infers AbstractElement: - ConditionalBranch ({infer Alternatives.elements+=current} ('|' elements+=ConditionalBranch)+)?; +Alternatives returns AbstractElement: + ConditionalBranch ({Alternatives.elements+=current} ('|' elements+=ConditionalBranch)+)?; -ConditionalBranch infers AbstractElement: +ConditionalBranch returns AbstractElement: UnorderedGroup - | {infer Group} '<' guardCondition=Disjunction '>' (elements+=AbstractToken)+; + | {Group} '<' guardCondition=Disjunction '>' (elements+=AbstractToken)+; -UnorderedGroup infers AbstractElement: - Group ({infer UnorderedGroup.elements+=current} ('&' elements+=Group)+)?; +UnorderedGroup returns AbstractElement: + Group ({UnorderedGroup.elements+=current} ('&' elements+=Group)+)?; -Group infers AbstractElement: - AbstractToken ({infer Group.elements+=current} elements+=AbstractToken+)?; +Group returns AbstractElement: + AbstractToken ({Group.elements+=current} elements+=AbstractToken+)?; -AbstractToken infers AbstractElement: +AbstractToken returns AbstractElement: AbstractTokenWithCardinality | Action; -AbstractTokenWithCardinality infers AbstractElement: +AbstractTokenWithCardinality returns AbstractElement: (Assignment | AbstractTerminal) cardinality=('?'|'*'|'+')?; -Action infers AbstractElement: - {infer Action} '{' (type=[AbstractType:ID] | inferredType=InferredType) ('.' feature=FeatureName operator=('='|'+=') 'current')? '}'; +Action returns AbstractElement: + {Action} '{' (type=[AbstractType:ID] | inferredType=InferredType) ('.' feature=FeatureName operator=('='|'+=') 'current')? '}'; -AbstractTerminal infers AbstractElement: +AbstractTerminal returns AbstractElement: Keyword | RuleCall | ParenthesizedElement | @@ -121,106 +122,106 @@ AbstractTerminal infers AbstractElement: PredicatedGroup | EndOfFile; -EndOfFile: - {infer EndOfFile} 'EOF'; +EndOfFile returns EndOfFile: + {EndOfFile} 'EOF'; -Keyword: +Keyword returns Keyword: value=STRING; -RuleCall: +RuleCall returns RuleCall: rule=[AbstractRule:ID] ('<' arguments+=NamedArgument (',' arguments+=NamedArgument)* '>')?; -NamedArgument: +NamedArgument returns NamedArgument: (parameter=[Parameter:ID] calledByName?='=')? value=Disjunction; -Disjunction infers Condition: - Conjunction ({infer Disjunction.left=current} '|' right=Conjunction)*; +Disjunction returns Condition: + Conjunction ({Disjunction.left=current} '|' right=Conjunction)*; -Conjunction infers Condition: - Negation ({infer Conjunction.left=current} '&' right=Negation)*; +Conjunction returns Condition: + Negation ({Conjunction.left=current} '&' right=Negation)*; -Negation infers Condition: - Atom | {infer Negation} '!' value=Negation; +Negation returns Condition: + Atom | {Negation} '!' value=Negation; -Atom infers Condition: +Atom returns Condition: ParameterReference | ParenthesizedCondition | BooleanLiteral; -ParenthesizedCondition infers Condition: +ParenthesizedCondition returns Condition: '(' Disjunction ')'; -ParameterReference: +ParameterReference returns ParameterReference: parameter=[Parameter:ID]; -PredicatedKeyword infers Keyword: +PredicatedKeyword returns Keyword: (predicate=('=>'|'->')) value=STRING; -PredicatedRuleCall infers RuleCall: +PredicatedRuleCall returns RuleCall: (predicate=('=>'|'->')) rule=[AbstractRule:ID] ('<' arguments+=NamedArgument (',' arguments+=NamedArgument)* '>')?; -Assignment infers AbstractElement: - {infer Assignment} (predicate=('=>'|'->'))? feature=FeatureName operator=('+='|'='|'?=') terminal=AssignableTerminal; +Assignment returns AbstractElement: + {Assignment} (predicate=('=>'|'->'))? feature=FeatureName operator=('+='|'='|'?=') terminal=AssignableTerminal; -AssignableTerminal infers AbstractElement: +AssignableTerminal returns AbstractElement: Keyword | RuleCall | ParenthesizedAssignableElement | CrossReference; -ParenthesizedAssignableElement infers AbstractElement: +ParenthesizedAssignableElement returns AbstractElement: '(' AssignableAlternatives ')'; -AssignableAlternatives infers AbstractElement: - AssignableTerminal ({infer Alternatives.elements+=current} ('|' elements+=AssignableTerminal)+)?; +AssignableAlternatives returns AbstractElement: + AssignableTerminal ({Alternatives.elements+=current} ('|' elements+=AssignableTerminal)+)?; -CrossReference infers AbstractElement: - {infer CrossReference} '[' type=[AbstractType] ((deprecatedSyntax?='|' | ':') terminal=CrossReferenceableTerminal )? ']'; +CrossReference returns AbstractElement: + {CrossReference} '[' type=[AbstractType:ID] ((deprecatedSyntax?='|' | ':') terminal=CrossReferenceableTerminal )? ']'; -CrossReferenceableTerminal infers AbstractElement: +CrossReferenceableTerminal returns AbstractElement: Keyword | RuleCall; -ParenthesizedElement infers AbstractElement: +ParenthesizedElement returns AbstractElement: '(' Alternatives ')'; -PredicatedGroup infers Group: +PredicatedGroup returns Group: (predicate=('=>'|'->')) '(' elements+=Alternatives ')'; -ReturnType: +ReturnType returns ReturnType: name=(PrimitiveType | ID); -TerminalRule: +TerminalRule returns TerminalRule: hidden?='hidden'? 'terminal' (fragment?='fragment' name=ID | name=ID ('returns' type=ReturnType)?) ':' definition=TerminalAlternatives ';'; -TerminalAlternatives infers AbstractElement: - TerminalGroup ({infer TerminalAlternatives.elements+=current} '|' elements+=TerminalGroup)*; +TerminalAlternatives returns TerminalElement: + TerminalGroup ({TerminalAlternatives.elements+=current} '|' elements+=TerminalGroup)*; -TerminalGroup infers AbstractElement: - TerminalToken ({infer TerminalGroup.elements+=current} elements+=TerminalToken+)?; +TerminalGroup returns TerminalElement: + TerminalToken ({TerminalGroup.elements+=current} elements+=TerminalToken+)?; -TerminalToken infers AbstractElement: +TerminalToken returns TerminalElement: TerminalTokenElement cardinality=('?'|'*'|'+')?; -TerminalTokenElement infers AbstractElement: +TerminalTokenElement returns TerminalElement: CharacterRange | TerminalRuleCall | ParenthesizedTerminalElement | NegatedToken | UntilToken | RegexToken | Wildcard; -ParenthesizedTerminalElement infers AbstractElement: '(' (lookahead=('?='|'?!'|'?<='|'?' terminal=TerminalTokenElement; +UntilToken returns TerminalElement: + {UntilToken} '->' terminal=TerminalTokenElement; -RegexToken infers AbstractElement: - {infer RegexToken} regex=RegexLiteral; +RegexToken returns TerminalElement: + {RegexToken} regex=RegexLiteral; -Wildcard infers AbstractElement: - {infer Wildcard} '.'; +Wildcard returns TerminalElement: + {Wildcard} '.'; -CharacterRange infers AbstractElement: - {infer CharacterRange} left=Keyword ('..' right=Keyword)?; +CharacterRange returns TerminalElement: + {CharacterRange} left=Keyword ('..' right=Keyword)?; FeatureName returns string: 'infix' | 'on' | 'right' | 'left' | 'assoc' | 'current' | 'entry' | 'extends' | 'false' | 'fragment' | 'grammar' | 'hidden' | 'import' | 'interface' | 'returns' | 'terminal' | 'true' | 'type' | 'infer' | 'infers' | 'with' | PrimitiveType | ID; diff --git a/packages/langium/src/grammar/langium-types.langium b/packages/langium/src/grammar/langium-types.langium new file mode 100644 index 000000000..4c1206c54 --- /dev/null +++ b/packages/langium/src/grammar/langium-types.langium @@ -0,0 +1,241 @@ +type AbstractRule = InfixRule | ParserRule | TerminalRule; + +type AbstractType = InferredType | InfixRule | Interface | ParserRule | Type; + +type Associativity = "left" | "right"; + +type Condition = BooleanLiteral | Conjunction | Disjunction | Negation | ParameterReference; + +type FeatureName = "assoc" | "current" | "entry" | "extends" | "false" | "fragment" | "grammar" | "hidden" | "import" | "infer" | "infers" | "infix" | "interface" | "left" | "on" | "returns" | "right" | "terminal" | "true" | "type" | "with" | PrimitiveType | string; + +type PrimitiveType = "Date" | "bigint" | "boolean" | "number" | "string"; + +type TypeDefinition = ArrayType | ReferenceType | SimpleType | UnionType; + +type ValueLiteral = ArrayLiteral | BooleanLiteral | NumberLiteral | StringLiteral; + +interface AbstractElement { + cardinality?: "*" | "+" | "?"; + // parenthesized: boolean; +} + +interface ArrayLiteral { + elements: ValueLiteral[]; +} + +interface ArrayType { + elementType: TypeDefinition; +} + +interface BooleanLiteral { + true: boolean; +} + +interface Conjunction { + left: Condition; + right: Condition; +} + +interface Disjunction { + left: Condition; + right: Condition; +} + +interface Grammar { + imports: GrammarImport[]; + interfaces: Interface[]; + isDeclared: boolean; + name?: string; + rules: AbstractRule[]; + types: Type[]; +} + +interface GrammarImport { + path: string; +} + +interface InferredType { + name: string; +} + +interface InfixRule { + call: RuleCall; + name: string; + operators: InfixRuleOperators; + parameters: Parameter[]; +} + +interface InfixRuleOperatorList { + associativity?: Associativity; + operators: Keyword[]; +} + +interface InfixRuleOperators { + precedences: InfixRuleOperatorList[]; +} + +interface Interface { + attributes: TypeAttribute[]; + name: string; + superTypes: @AbstractType[]; +} + +interface NamedArgument { + calledByName: boolean; + parameter?: @Parameter; + value: Condition; +} + +interface Negation { + value: Condition; +} + +interface NumberLiteral { + value: number; +} + +interface Parameter { + name: string; +} + +interface ParameterReference { + parameter: @Parameter; +} + +interface ParserRule { + dataType?: PrimitiveType; + definition: AbstractElement; + entry: boolean; + fragment: boolean; + inferredType?: InferredType; + name: string; + parameters: Parameter[]; + returnType?: @AbstractType; +} + +interface ReferenceType { + referenceType: TypeDefinition; +} + +interface ReturnType { + name: PrimitiveType | string; +} + +interface SimpleType { + primitiveType?: PrimitiveType; + stringType?: string; + typeRef?: @AbstractType; +} + +interface StringLiteral { + value: string; +} + +interface TerminalRule { + definition: TerminalElement; + fragment: boolean; + hidden: boolean; + name: string; + type?: ReturnType; +} + +interface Type { + name: string; + type: TypeDefinition; +} + +interface TypeAttribute { + defaultValue?: ValueLiteral; + isOptional: boolean; + name: FeatureName; + type: TypeDefinition; +} + +interface UnionType { + types: TypeDefinition[]; +} + +interface Action extends AbstractElement { + feature?: FeatureName; + inferredType?: InferredType; + operator?: "+=" | "="; + type?: @AbstractType; +} + +interface Alternatives extends AbstractElement { + elements: AbstractElement[]; +} + +interface Assignment extends AbstractElement { + feature: FeatureName; + operator: "+=" | "=" | "?="; + predicate?: "->" | "=>"; + terminal: AbstractElement; +} + +interface CharacterRange extends TerminalElement { + left: Keyword; + right?: Keyword; +} + +interface CrossReference extends AbstractElement { + deprecatedSyntax: boolean; + terminal?: AbstractElement; + type: @AbstractType; +} + +interface EndOfFile extends AbstractElement { +} + +interface Group extends AbstractElement { + elements: AbstractElement[]; + guardCondition?: Condition; + predicate?: "->" | "=>"; +} + +interface Keyword extends AbstractElement { + predicate?: "->" | "=>"; + value: string; +} + +interface NegatedToken extends TerminalElement { + terminal: AbstractElement; +} + +interface RegexToken extends TerminalElement { + regex: string; +} + +interface RuleCall extends AbstractElement { + arguments: NamedArgument[]; + predicate?: "->" | "=>"; + rule: @AbstractRule; +} + +interface TerminalAlternatives extends TerminalElement { + elements: AbstractElement[]; +} + +interface TerminalElement extends AbstractElement { + lookahead?: "?!" | "?; + predicate?: '->' | '=>'; + rule: langium.Reference; +} + +export const RuleCall = { + $type: 'RuleCall', + arguments: 'arguments', + cardinality: 'cardinality', + predicate: 'predicate', + rule: 'rule' +} as const; + +export function isRuleCall(item: unknown): item is RuleCall { + return reflection.isInstance(item, RuleCall.$type); +} + +export interface TerminalElement extends AbstractElement { + readonly $type: 'CharacterRange' | 'NegatedToken' | 'RegexToken' | 'TerminalAlternatives' | 'TerminalElement' | 'TerminalGroup' | 'TerminalRuleCall' | 'UnorderedGroup' | 'UntilToken' | 'Wildcard'; + lookahead?: '?!' | '?; - predicate?: '->' | '=>'; - rule: langium.Reference; -} - -export const RuleCall = { - $type: 'RuleCall', - arguments: 'arguments', - cardinality: 'cardinality', - lookahead: 'lookahead', - predicate: 'predicate', - rule: 'rule' -} as const; - -export function isRuleCall(item: unknown): item is RuleCall { - return reflection.isInstance(item, RuleCall.$type); -} - -export interface TerminalAlternatives extends AbstractElement { +export interface TerminalAlternatives extends TerminalElement { readonly $type: 'TerminalAlternatives'; elements: Array; } @@ -827,14 +825,15 @@ export const TerminalAlternatives = { $type: 'TerminalAlternatives', cardinality: 'cardinality', elements: 'elements', - lookahead: 'lookahead' + lookahead: 'lookahead', + parenthesized: 'parenthesized' } as const; export function isTerminalAlternatives(item: unknown): item is TerminalAlternatives { return reflection.isInstance(item, TerminalAlternatives.$type); } -export interface TerminalGroup extends AbstractElement { +export interface TerminalGroup extends TerminalElement { readonly $type: 'TerminalGroup'; elements: Array; } @@ -843,14 +842,15 @@ export const TerminalGroup = { $type: 'TerminalGroup', cardinality: 'cardinality', elements: 'elements', - lookahead: 'lookahead' + lookahead: 'lookahead', + parenthesized: 'parenthesized' } as const; export function isTerminalGroup(item: unknown): item is TerminalGroup { return reflection.isInstance(item, TerminalGroup.$type); } -export interface TerminalRuleCall extends AbstractElement { +export interface TerminalRuleCall extends TerminalElement { readonly $type: 'TerminalRuleCall'; rule: langium.Reference; } @@ -859,6 +859,7 @@ export const TerminalRuleCall = { $type: 'TerminalRuleCall', cardinality: 'cardinality', lookahead: 'lookahead', + parenthesized: 'parenthesized', rule: 'rule' } as const; @@ -866,7 +867,7 @@ export function isTerminalRuleCall(item: unknown): item is TerminalRuleCall { return reflection.isInstance(item, TerminalRuleCall.$type); } -export interface UnorderedGroup extends AbstractElement { +export interface UnorderedGroup extends TerminalElement { readonly $type: 'UnorderedGroup'; elements: Array; } @@ -875,14 +876,15 @@ export const UnorderedGroup = { $type: 'UnorderedGroup', cardinality: 'cardinality', elements: 'elements', - lookahead: 'lookahead' + lookahead: 'lookahead', + parenthesized: 'parenthesized' } as const; export function isUnorderedGroup(item: unknown): item is UnorderedGroup { return reflection.isInstance(item, UnorderedGroup.$type); } -export interface UntilToken extends AbstractElement { +export interface UntilToken extends TerminalElement { readonly $type: 'UntilToken'; terminal: AbstractElement; } @@ -891,6 +893,7 @@ export const UntilToken = { $type: 'UntilToken', cardinality: 'cardinality', lookahead: 'lookahead', + parenthesized: 'parenthesized', terminal: 'terminal' } as const; @@ -898,14 +901,15 @@ export function isUntilToken(item: unknown): item is UntilToken { return reflection.isInstance(item, UntilToken.$type); } -export interface Wildcard extends AbstractElement { +export interface Wildcard extends TerminalElement { readonly $type: 'Wildcard'; } export const Wildcard = { $type: 'Wildcard', cardinality: 'cardinality', - lookahead: 'lookahead' + lookahead: 'lookahead', + parenthesized: 'parenthesized' } as const; export function isWildcard(item: unknown): item is Wildcard { @@ -951,6 +955,7 @@ export type LangiumGrammarAstType = { SimpleType: SimpleType StringLiteral: StringLiteral TerminalAlternatives: TerminalAlternatives + TerminalElement: TerminalElement TerminalGroup: TerminalGroup TerminalRule: TerminalRule TerminalRuleCall: TerminalRuleCall @@ -971,9 +976,6 @@ export class LangiumGrammarAstReflection extends langium.AbstractAstReflection { properties: { cardinality: { name: 'cardinality' - }, - lookahead: { - name: 'lookahead' } }, superTypes: [] @@ -990,9 +992,6 @@ export class LangiumGrammarAstReflection extends langium.AbstractAstReflection { inferredType: { name: 'inferredType' }, - lookahead: { - name: 'lookahead' - }, operator: { name: 'operator' }, @@ -1012,9 +1011,6 @@ export class LangiumGrammarAstReflection extends langium.AbstractAstReflection { elements: { name: 'elements', defaultValue: [] - }, - lookahead: { - name: 'lookahead' } }, superTypes: ['AbstractElement'] @@ -1047,9 +1043,6 @@ export class LangiumGrammarAstReflection extends langium.AbstractAstReflection { feature: { name: 'feature' }, - lookahead: { - name: 'lookahead' - }, operator: { name: 'operator' }, @@ -1084,11 +1077,15 @@ export class LangiumGrammarAstReflection extends langium.AbstractAstReflection { lookahead: { name: 'lookahead' }, + parenthesized: { + name: 'parenthesized', + defaultValue: false + }, right: { name: 'right' } }, - superTypes: ['AbstractElement'] + superTypes: ['TerminalElement'] }, Conjunction: { name: Conjunction.$type, @@ -1112,9 +1109,6 @@ export class LangiumGrammarAstReflection extends langium.AbstractAstReflection { name: 'deprecatedSyntax', defaultValue: false }, - lookahead: { - name: 'lookahead' - }, terminal: { name: 'terminal' }, @@ -1142,9 +1136,6 @@ export class LangiumGrammarAstReflection extends langium.AbstractAstReflection { properties: { cardinality: { name: 'cardinality' - }, - lookahead: { - name: 'lookahead' } }, superTypes: ['AbstractElement'] @@ -1200,9 +1191,6 @@ export class LangiumGrammarAstReflection extends langium.AbstractAstReflection { guardCondition: { name: 'guardCondition' }, - lookahead: { - name: 'lookahead' - }, predicate: { name: 'predicate' } @@ -1284,9 +1272,6 @@ export class LangiumGrammarAstReflection extends langium.AbstractAstReflection { cardinality: { name: 'cardinality' }, - lookahead: { - name: 'lookahead' - }, predicate: { name: 'predicate' }, @@ -1322,11 +1307,15 @@ export class LangiumGrammarAstReflection extends langium.AbstractAstReflection { lookahead: { name: 'lookahead' }, + parenthesized: { + name: 'parenthesized', + defaultValue: false + }, terminal: { name: 'terminal' } }, - superTypes: ['AbstractElement'] + superTypes: ['TerminalElement'] }, Negation: { name: Negation.$type, @@ -1417,11 +1406,15 @@ export class LangiumGrammarAstReflection extends langium.AbstractAstReflection { lookahead: { name: 'lookahead' }, + parenthesized: { + name: 'parenthesized', + defaultValue: false + }, regex: { name: 'regex' } }, - superTypes: ['AbstractElement'] + superTypes: ['TerminalElement'] }, ReturnType: { name: ReturnType.$type, @@ -1442,9 +1435,6 @@ export class LangiumGrammarAstReflection extends langium.AbstractAstReflection { cardinality: { name: 'cardinality' }, - lookahead: { - name: 'lookahead' - }, predicate: { name: 'predicate' }, @@ -1492,6 +1482,26 @@ export class LangiumGrammarAstReflection extends langium.AbstractAstReflection { }, lookahead: { name: 'lookahead' + }, + parenthesized: { + name: 'parenthesized', + defaultValue: false + } + }, + superTypes: ['TerminalElement'] + }, + TerminalElement: { + name: TerminalElement.$type, + properties: { + cardinality: { + name: 'cardinality' + }, + lookahead: { + name: 'lookahead' + }, + parenthesized: { + name: 'parenthesized', + defaultValue: false } }, superTypes: ['AbstractElement'] @@ -1508,9 +1518,13 @@ export class LangiumGrammarAstReflection extends langium.AbstractAstReflection { }, lookahead: { name: 'lookahead' + }, + parenthesized: { + name: 'parenthesized', + defaultValue: false } }, - superTypes: ['AbstractElement'] + superTypes: ['TerminalElement'] }, TerminalRule: { name: TerminalRule.$type, @@ -1544,12 +1558,16 @@ export class LangiumGrammarAstReflection extends langium.AbstractAstReflection { lookahead: { name: 'lookahead' }, + parenthesized: { + name: 'parenthesized', + defaultValue: false + }, rule: { name: 'rule', referenceType: 'TerminalRule' } }, - superTypes: ['AbstractElement'] + superTypes: ['TerminalElement'] }, Type: { name: Type.$type, @@ -1604,9 +1622,13 @@ export class LangiumGrammarAstReflection extends langium.AbstractAstReflection { }, lookahead: { name: 'lookahead' + }, + parenthesized: { + name: 'parenthesized', + defaultValue: false } }, - superTypes: ['AbstractElement'] + superTypes: ['TerminalElement'] }, UntilToken: { name: UntilToken.$type, @@ -1617,11 +1639,15 @@ export class LangiumGrammarAstReflection extends langium.AbstractAstReflection { lookahead: { name: 'lookahead' }, + parenthesized: { + name: 'parenthesized', + defaultValue: false + }, terminal: { name: 'terminal' } }, - superTypes: ['AbstractElement'] + superTypes: ['TerminalElement'] }, Wildcard: { name: Wildcard.$type, @@ -1631,9 +1657,13 @@ export class LangiumGrammarAstReflection extends langium.AbstractAstReflection { }, lookahead: { name: 'lookahead' + }, + parenthesized: { + name: 'parenthesized', + defaultValue: false } }, - superTypes: ['AbstractElement'] + superTypes: ['TerminalElement'] } } as const satisfies langium.AstMetaData } From b480d83f96ded693affa379b9e8f17d56688b4c2 Mon Sep 17 00:00:00 2001 From: Christian Schneider Date: Tue, 24 Jun 2025 13:07:10 +0200 Subject: [PATCH 2/2] langium grammar: updated conversion of EBNF-like terminal definitions to RegExp now avoiding unnecessary capturing groups '(...)' * added 'paranthesized' flag to type TerminalElement * marked required synthetic groups as non-capturing '(?:...)' * updated tests * updated example languages --- .../src/language-server/generated/grammar.ts | 15 +++++--- .../src/language-server/generated/grammar.ts | 12 ++++--- .../src/language-server/generated/grammar.ts | 36 ++++++++++++------- .../src/language-server/generated/grammar.ts | 12 ++++--- .../test/generator/ast-generator.test.ts | 2 +- .../src/grammar/langium-grammar.langium | 2 +- .../langium/src/grammar/langium-types.langium | 1 + packages/langium/src/utils/grammar-utils.ts | 31 +++++++++++----- .../langium/test/grammar/grammar-util.test.ts | 14 ++++---- 9 files changed, 82 insertions(+), 43 deletions(-) diff --git a/examples/arithmetics/src/language-server/generated/grammar.ts b/examples/arithmetics/src/language-server/generated/grammar.ts index 785602d82..065010c50 100644 --- a/examples/arithmetics/src/language-server/generated/grammar.ts +++ b/examples/arithmetics/src/language-server/generated/grammar.ts @@ -435,7 +435,8 @@ export const ArithmeticsGrammar = (): Grammar => loadedArithmeticsGrammar ?? (lo "name": "WS", "definition": { "$type": "RegexToken", - "regex": "/\\\\s+/" + "regex": "/\\\\s+/", + "parenthesized": false }, "fragment": false }, @@ -444,7 +445,8 @@ export const ArithmeticsGrammar = (): Grammar => loadedArithmeticsGrammar ?? (lo "name": "ID", "definition": { "$type": "RegexToken", - "regex": "/[_a-zA-Z][\\\\w_]*/" + "regex": "/[_a-zA-Z][\\\\w_]*/", + "parenthesized": false }, "fragment": false, "hidden": false @@ -458,7 +460,8 @@ export const ArithmeticsGrammar = (): Grammar => loadedArithmeticsGrammar ?? (lo }, "definition": { "$type": "RegexToken", - "regex": "/[0-9]+(\\\\.[0-9]*)?/" + "regex": "/[0-9]+(\\\\.[0-9]*)?/", + "parenthesized": false }, "fragment": false, "hidden": false @@ -469,7 +472,8 @@ export const ArithmeticsGrammar = (): Grammar => loadedArithmeticsGrammar ?? (lo "name": "ML_COMMENT", "definition": { "$type": "RegexToken", - "regex": "/\\\\/\\\\*[\\\\s\\\\S]*?\\\\*\\\\//" + "regex": "/\\\\/\\\\*[\\\\s\\\\S]*?\\\\*\\\\//", + "parenthesized": false }, "fragment": false }, @@ -479,7 +483,8 @@ export const ArithmeticsGrammar = (): Grammar => loadedArithmeticsGrammar ?? (lo "name": "SL_COMMENT", "definition": { "$type": "RegexToken", - "regex": "/\\\\/\\\\/[^\\\\n\\\\r]*/" + "regex": "/\\\\/\\\\/[^\\\\n\\\\r]*/", + "parenthesized": false }, "fragment": false } diff --git a/examples/domainmodel/src/language-server/generated/grammar.ts b/examples/domainmodel/src/language-server/generated/grammar.ts index 3135194af..9f8eb54a3 100644 --- a/examples/domainmodel/src/language-server/generated/grammar.ts +++ b/examples/domainmodel/src/language-server/generated/grammar.ts @@ -339,7 +339,8 @@ export const DomainModelGrammar = (): Grammar => loadedDomainModelGrammar ?? (lo "name": "WS", "definition": { "$type": "RegexToken", - "regex": "/\\\\s+/" + "regex": "/\\\\s+/", + "parenthesized": false }, "fragment": false }, @@ -348,7 +349,8 @@ export const DomainModelGrammar = (): Grammar => loadedDomainModelGrammar ?? (lo "name": "ID", "definition": { "$type": "RegexToken", - "regex": "/[_a-zA-Z][\\\\w_]*/" + "regex": "/[_a-zA-Z][\\\\w_]*/", + "parenthesized": false }, "fragment": false, "hidden": false @@ -359,7 +361,8 @@ export const DomainModelGrammar = (): Grammar => loadedDomainModelGrammar ?? (lo "name": "ML_COMMENT", "definition": { "$type": "RegexToken", - "regex": "/\\\\/\\\\*[\\\\s\\\\S]*?\\\\*\\\\//" + "regex": "/\\\\/\\\\*[\\\\s\\\\S]*?\\\\*\\\\//", + "parenthesized": false }, "fragment": false }, @@ -369,7 +372,8 @@ export const DomainModelGrammar = (): Grammar => loadedDomainModelGrammar ?? (lo "name": "SL_COMMENT", "definition": { "$type": "RegexToken", - "regex": "/\\\\/\\\\/[^\\\\n\\\\r]*/" + "regex": "/\\\\/\\\\/[^\\\\n\\\\r]*/", + "parenthesized": false }, "fragment": false } diff --git a/examples/requirements/src/language-server/generated/grammar.ts b/examples/requirements/src/language-server/generated/grammar.ts index c76851e9c..e72ed9574 100644 --- a/examples/requirements/src/language-server/generated/grammar.ts +++ b/examples/requirements/src/language-server/generated/grammar.ts @@ -234,7 +234,8 @@ export const RequirementsGrammar = (): Grammar => loadedRequirementsGrammar ?? ( "name": "WS", "definition": { "$type": "RegexToken", - "regex": "/\\\\s+/" + "regex": "/\\\\s+/", + "parenthesized": false }, "fragment": false }, @@ -243,7 +244,8 @@ export const RequirementsGrammar = (): Grammar => loadedRequirementsGrammar ?? ( "name": "ID", "definition": { "$type": "RegexToken", - "regex": "/[_a-zA-Z][\\\\w_]*/" + "regex": "/[_a-zA-Z][\\\\w_]*/", + "parenthesized": false }, "fragment": false, "hidden": false @@ -257,7 +259,8 @@ export const RequirementsGrammar = (): Grammar => loadedRequirementsGrammar ?? ( }, "definition": { "$type": "RegexToken", - "regex": "/[0-9]+/" + "regex": "/[0-9]+/", + "parenthesized": false }, "fragment": false, "hidden": false @@ -267,7 +270,8 @@ export const RequirementsGrammar = (): Grammar => loadedRequirementsGrammar ?? ( "name": "STRING", "definition": { "$type": "RegexToken", - "regex": "/\\"(\\\\\\\\.|[^\\"\\\\\\\\])*\\"|'(\\\\\\\\.|[^'\\\\\\\\])*'/" + "regex": "/\\"(\\\\\\\\.|[^\\"\\\\\\\\])*\\"|'(\\\\\\\\.|[^'\\\\\\\\])*'/", + "parenthesized": false }, "fragment": false, "hidden": false @@ -278,7 +282,8 @@ export const RequirementsGrammar = (): Grammar => loadedRequirementsGrammar ?? ( "name": "ML_COMMENT", "definition": { "$type": "RegexToken", - "regex": "/\\\\/\\\\*[\\\\s\\\\S]*?\\\\*\\\\//" + "regex": "/\\\\/\\\\*[\\\\s\\\\S]*?\\\\*\\\\//", + "parenthesized": false }, "fragment": false }, @@ -288,7 +293,8 @@ export const RequirementsGrammar = (): Grammar => loadedRequirementsGrammar ?? ( "name": "SL_COMMENT", "definition": { "$type": "RegexToken", - "regex": "/\\\\/\\\\/[^\\\\n\\\\r]*/" + "regex": "/\\\\/\\\\/[^\\\\n\\\\r]*/", + "parenthesized": false }, "fragment": false } @@ -717,7 +723,8 @@ export const TestsGrammar = (): Grammar => loadedTestsGrammar ?? (loadedTestsGra "name": "WS", "definition": { "$type": "RegexToken", - "regex": "/\\\\s+/" + "regex": "/\\\\s+/", + "parenthesized": false }, "fragment": false }, @@ -726,7 +733,8 @@ export const TestsGrammar = (): Grammar => loadedTestsGrammar ?? (loadedTestsGra "name": "ID", "definition": { "$type": "RegexToken", - "regex": "/[_a-zA-Z][\\\\w_]*/" + "regex": "/[_a-zA-Z][\\\\w_]*/", + "parenthesized": false }, "fragment": false, "hidden": false @@ -740,7 +748,8 @@ export const TestsGrammar = (): Grammar => loadedTestsGrammar ?? (loadedTestsGra }, "definition": { "$type": "RegexToken", - "regex": "/[0-9]+/" + "regex": "/[0-9]+/", + "parenthesized": false }, "fragment": false, "hidden": false @@ -750,7 +759,8 @@ export const TestsGrammar = (): Grammar => loadedTestsGrammar ?? (loadedTestsGra "name": "STRING", "definition": { "$type": "RegexToken", - "regex": "/\\"(\\\\\\\\.|[^\\"\\\\\\\\])*\\"|'(\\\\\\\\.|[^'\\\\\\\\])*'/" + "regex": "/\\"(\\\\\\\\.|[^\\"\\\\\\\\])*\\"|'(\\\\\\\\.|[^'\\\\\\\\])*'/", + "parenthesized": false }, "fragment": false, "hidden": false @@ -761,7 +771,8 @@ export const TestsGrammar = (): Grammar => loadedTestsGrammar ?? (loadedTestsGra "name": "ML_COMMENT", "definition": { "$type": "RegexToken", - "regex": "/\\\\/\\\\*[\\\\s\\\\S]*?\\\\*\\\\//" + "regex": "/\\\\/\\\\*[\\\\s\\\\S]*?\\\\*\\\\//", + "parenthesized": false }, "fragment": false }, @@ -771,7 +782,8 @@ export const TestsGrammar = (): Grammar => loadedTestsGrammar ?? (loadedTestsGra "name": "SL_COMMENT", "definition": { "$type": "RegexToken", - "regex": "/\\\\/\\\\/[^\\\\n\\\\r]*/" + "regex": "/\\\\/\\\\/[^\\\\n\\\\r]*/", + "parenthesized": false }, "fragment": false } diff --git a/examples/statemachine/src/language-server/generated/grammar.ts b/examples/statemachine/src/language-server/generated/grammar.ts index a0c99ab62..54f6cddd4 100644 --- a/examples/statemachine/src/language-server/generated/grammar.ts +++ b/examples/statemachine/src/language-server/generated/grammar.ts @@ -287,7 +287,8 @@ export const StatemachineGrammar = (): Grammar => loadedStatemachineGrammar ?? ( "name": "WS", "definition": { "$type": "RegexToken", - "regex": "/\\\\s+/" + "regex": "/\\\\s+/", + "parenthesized": false }, "fragment": false }, @@ -296,7 +297,8 @@ export const StatemachineGrammar = (): Grammar => loadedStatemachineGrammar ?? ( "name": "ID", "definition": { "$type": "RegexToken", - "regex": "/[_a-zA-Z][\\\\w_]*/" + "regex": "/[_a-zA-Z][\\\\w_]*/", + "parenthesized": false }, "fragment": false, "hidden": false @@ -307,7 +309,8 @@ export const StatemachineGrammar = (): Grammar => loadedStatemachineGrammar ?? ( "name": "ML_COMMENT", "definition": { "$type": "RegexToken", - "regex": "/\\\\/\\\\*[\\\\s\\\\S]*?\\\\*\\\\//" + "regex": "/\\\\/\\\\*[\\\\s\\\\S]*?\\\\*\\\\//", + "parenthesized": false }, "fragment": false }, @@ -317,7 +320,8 @@ export const StatemachineGrammar = (): Grammar => loadedStatemachineGrammar ?? ( "name": "SL_COMMENT", "definition": { "$type": "RegexToken", - "regex": "/\\\\/\\\\/[^\\\\n\\\\r]*/" + "regex": "/\\\\/\\\\/[^\\\\n\\\\r]*/", + "parenthesized": false }, "fragment": false } diff --git a/packages/langium-cli/test/generator/ast-generator.test.ts b/packages/langium-cli/test/generator/ast-generator.test.ts index 3237c097f..e82c5e792 100644 --- a/packages/langium-cli/test/generator/ast-generator.test.ts +++ b/packages/langium-cli/test/generator/ast-generator.test.ts @@ -354,7 +354,7 @@ describe('Ast generator', () => { `, expandToString` export const TestTerminals = { WS: /\\s+/, - NUMBER: /([0-9])+/, + NUMBER: /(?:[0-9])+/, }; `)); diff --git a/packages/langium/src/grammar/langium-grammar.langium b/packages/langium/src/grammar/langium-grammar.langium index 9a588117d..f282041f5 100644 --- a/packages/langium/src/grammar/langium-grammar.langium +++ b/packages/langium/src/grammar/langium-grammar.langium @@ -202,8 +202,8 @@ TerminalToken returns TerminalElement: TerminalTokenElement returns TerminalElement: CharacterRange | TerminalRuleCall | ParenthesizedTerminalElement | NegatedToken | UntilToken | RegexToken | Wildcard; - '(' (lookahead=('?='|'?!'|'?<='|'? abstractElementToRegex(e)).join('|'), { cardinality: alternatives.cardinality, - lookahead: alternatives.lookahead + lookahead: alternatives.lookahead, + parenthesized: alternatives.parenthesized, + wrap: false // wrapping is not required for top level alternatives, and nested alternatives are already parenthesized according to the grammar }); } function terminalGroupToRegex(group: ast.TerminalGroup): string { return withCardinality(group.elements.map(e => abstractElementToRegex(e)).join(''), { cardinality: group.cardinality, - lookahead: group.lookahead + lookahead: group.lookahead, + parenthesized: group.parenthesized, + wrap: false // wrapping is not required for top level group, and nested group are already parenthesized according to the grammar }); } function untilTokenToRegex(until: ast.UntilToken): string { return withCardinality(`${WILDCARD}*?${abstractElementToRegex(until.terminal)}`, { cardinality: until.cardinality, - lookahead: until.lookahead + lookahead: until.lookahead, + parenthesized: until.parenthesized }); } function negateTokenToRegex(negate: ast.NegatedToken): string { return withCardinality(`(?!${abstractElementToRegex(negate.terminal)})${WILDCARD}*?`, { cardinality: negate.cardinality, - lookahead: negate.lookahead + lookahead: negate.lookahead, + parenthesized: negate.parenthesized }); } @@ -598,12 +607,14 @@ function characterRangeToRegex(range: ast.CharacterRange): string { return withCardinality(`[${keywordToRegex(range.left)}-${keywordToRegex(range.right)}]`, { cardinality: range.cardinality, lookahead: range.lookahead, + parenthesized: range.parenthesized, wrap: false }); } return withCardinality(keywordToRegex(range.left), { cardinality: range.cardinality, lookahead: range.lookahead, + parenthesized: range.parenthesized, wrap: false }); } @@ -614,11 +625,13 @@ function keywordToRegex(keyword: ast.Keyword): string { function withCardinality(regex: string, options: { cardinality?: string - wrap?: boolean + parenthesized: boolean lookahead?: string + wrap?: boolean }): string { - if (options.wrap !== false || options.lookahead) { - regex = `(${options.lookahead ?? ''}${regex})`; + if (options.parenthesized || options.lookahead || options.wrap !== false) { + const groupConfig = options.lookahead ?? (options.parenthesized ? '' : '?:'); + regex = `(${groupConfig}${regex})`; } if (options.cardinality) { return `${regex}${options.cardinality}`; diff --git a/packages/langium/test/grammar/grammar-util.test.ts b/packages/langium/test/grammar/grammar-util.test.ts index 23fd2d190..567950ba2 100644 --- a/packages/langium/test/grammar/grammar-util.test.ts +++ b/packages/langium/test/grammar/grammar-util.test.ts @@ -143,7 +143,7 @@ describe('TerminalRule to regex', () => { test('Should create combined regexes', async () => { const terminal = await getTerminal('terminal X: /x/ /y/;'); const regex = terminalRegex(terminal); - expect(regex).toEqual(/(xy)/); + expect(regex).toEqual(/xy/); }); test('Should create optional alternatives with keywords', async () => { @@ -155,31 +155,31 @@ describe('TerminalRule to regex', () => { test('Should create positive lookahead group with single element', async () => { const terminal = await getTerminal("terminal X: 'a' (?='b');"); const regex = terminalRegex(terminal); - expect(regex).toEqual(/(a(?=b))/); + expect(regex).toEqual(/a(?=b)/); }); test('Should create positive lookahead group with multiple elements', async () => { const terminal = await getTerminal("terminal X: 'a' (?='b' 'c' 'd');"); const regex = terminalRegex(terminal); - expect(regex).toEqual(/(a(?=bcd))/); + expect(regex).toEqual(/a(?=bcd)/); }); test('Should create negative lookahead group', async () => { const terminal = await getTerminal("terminal X: 'a' (?!'b');"); const regex = terminalRegex(terminal); - expect(regex).toEqual(/(a(?!b))/); + expect(regex).toEqual(/a(?!b)/); }); test('Should create negative lookbehind group', async () => { const terminal = await getTerminal("terminal X: 'a' (? { const terminal = await getTerminal("terminal X: 'a' (?<='b');"); const regex = terminalRegex(terminal); - expect(regex).toEqual(/(a(?<=b))/); + expect(regex).toEqual(/a(?<=b)/); }); test('Should create terminal reference in terminal definition', async () => { @@ -188,7 +188,7 @@ describe('TerminalRule to regex', () => { terminal Y: 'a'; `, 'X'); const regex = terminalRegex(terminal); - expect(regex).toEqual(/((a)(a))/); + expect(regex).toEqual(/(?:a)(?:a)/); }); test('Should create negated token', async () => {