Make entry rule explicit (#305)

eclipse-langium · Nov 18, 2021 · f3b04b4 · f3b04b4
1 parent 62898bd
commit f3b04b4
Show file tree

Hide file tree

Showing 16 changed files with 72 additions and 46 deletions.
diff --git a/examples/arithmetics/src/language-server/arithmetics.langium b/examples/arithmetics/src/language-server/arithmetics.langium
@@ -1,6 +1,6 @@
 grammar Arithmetics
 
-Module:
+entry Module:
 	'module' name=ID
 	(statements+=Statement)*;
 

diff --git a/examples/arithmetics/src/language-server/generated/grammar.ts b/examples/arithmetics/src/language-server/generated/grammar.ts
@@ -17,6 +17,7 @@ export const grammar = (): Grammar => loaded || (loaded = loadGrammar(`{
       "parameters": [],
       "name": "Module",
       "hiddenTokens": [],
+      "entry": true,
       "alternatives": {
         "$type": "Group",
         "elements": [

diff --git a/examples/domainmodel/src/language-server/domain-model.langium b/examples/domainmodel/src/language-server/domain-model.langium
@@ -1,6 +1,6 @@
 grammar DomainModel
 
-Domainmodel:
+entry Domainmodel:
     (elements+=AbstractElement)*;
 
 AbstractElement:

diff --git a/examples/domainmodel/src/language-server/generated/grammar.ts b/examples/domainmodel/src/language-server/generated/grammar.ts
@@ -17,6 +17,7 @@ export const grammar = (): Grammar => loaded || (loaded = loadGrammar(`{
       "parameters": [],
       "name": "Domainmodel",
       "hiddenTokens": [],
+      "entry": true,
       "alternatives": {
         "$type": "Assignment",
         "feature": "elements",

diff --git a/examples/statemachine/src/language-server/generated/grammar.ts b/examples/statemachine/src/language-server/generated/grammar.ts
@@ -17,6 +17,7 @@ export const grammar = (): Grammar => loaded || (loaded = loadGrammar(`{
       "parameters": [],
       "name": "Statemachine",
       "hiddenTokens": [],
+      "entry": true,
       "alternatives": {
         "$type": "Group",
         "elements": [

diff --git a/examples/statemachine/src/language-server/statemachine.langium b/examples/statemachine/src/language-server/statemachine.langium
@@ -1,6 +1,6 @@
 grammar Statemachine
 
-Statemachine:
+entry Statemachine:
 	'statemachine' name=ID
 	('events' events+=Event+)?
 	('commands'	commands+=Command+)?

diff --git a/package-lock.json b/package-lock.json
diff --git a/packages/langium-vscode/data/langium.tmLanguage.json b/packages/langium-vscode/data/langium.tmLanguage.json
@@ -13,7 +13,7 @@
         },
         {
             "name": "keyword.control.langium",
-            "match": "\\b(grammar|terminal|enum|fragment|hidden|generate|as|with|import|returns)\\b"
+            "match": "\\b(grammar|terminal|enum|entry|fragment|hidden|generate|as|with|import|returns)\\b"
         },
         {
             "name": "constant.language.langium",

diff --git a/packages/langium/src/documents/document-builder.ts b/packages/langium/src/documents/document-builder.ts
@@ -6,7 +6,6 @@
 
 import { CancellationToken, Connection, Diagnostic } from 'vscode-languageserver';
 import { DocumentValidator } from '../validation/document-validator';
-import { LangiumParser } from '../parser/langium-parser';
 import { ScopeComputation } from '../references/scope';
 import { LangiumServices } from '../services';
 import { DocumentState, LangiumDocument, LangiumDocuments } from './document';
@@ -47,7 +46,6 @@ export interface BuildResult<T extends AstNode = AstNode> {
 
 export class DefaultDocumentBuilder implements DocumentBuilder {
     protected readonly connection?: Connection;
-    protected readonly parser: LangiumParser;
     protected readonly scopeComputation: ScopeComputation;
     protected readonly documentValidator: DocumentValidator;
     protected readonly langiumDocuments: LangiumDocuments;
@@ -56,7 +54,6 @@ export class DefaultDocumentBuilder implements DocumentBuilder {
 
     constructor(services: LangiumServices) {
         this.connection = services.lsp.Connection;
-        this.parser = services.parser.LangiumParser;
         this.linker = services.references.Linker;
         this.scopeComputation = services.references.ScopeComputation;
         this.documentValidator = services.validation.DocumentValidator;

diff --git a/packages/langium/src/grammar/generated/ast.ts b/packages/langium/src/grammar/generated/ast.ts
@@ -299,6 +299,7 @@ export function isReferencedMetamodel(item: unknown): item is ReferencedMetamode
 export interface ParserRule extends AbstractRule {
     alternatives: AbstractElement
     definesHiddenTokens: boolean
+    entry: boolean
     hiddenTokens: Array<Reference<AbstractRule>>
     parameters: Array<Parameter>
     wildcard: boolean

diff --git a/packages/langium/src/grammar/generated/grammar.ts b/packages/langium/src/grammar/generated/grammar.ts
@@ -77,6 +77,7 @@ export const grammar = (): Grammar => loaded || (loaded = loadGrammar(`{
       "parameters": [],
       "name": "Grammar",
       "hiddenTokens": [],
+      "entry": true,
       "alternatives": {
         "$type": "Group",
         "elements": [
@@ -474,14 +475,29 @@ export const grammar = (): Grammar => loaded || (loaded = loadGrammar(`{
                 "$type": "Group",
                 "elements": [
                   {
-                    "$type": "Assignment",
-                    "feature": "fragment",
-                    "operator": "?=",
-                    "terminal": {
-                      "$type": "Keyword",
-                      "value": "fragment"
-                    },
-                    "elements": []
+                    "$type": "Alternatives",
+                    "elements": [
+                      {
+                        "$type": "Assignment",
+                        "feature": "entry",
+                        "operator": "?=",
+                        "terminal": {
+                          "$type": "Keyword",
+                          "value": "entry"
+                        },
+                        "elements": []
+                      },
+                      {
+                        "$type": "Assignment",
+                        "feature": "fragment",
+                        "operator": "?=",
+                        "terminal": {
+                          "$type": "Keyword",
+                          "value": "fragment"
+                        },
+                        "elements": []
+                      }
+                    ]
                   },
                   {
                     "$type": "RuleCall",

diff --git a/packages/langium/src/grammar/grammar-util.ts b/packages/langium/src/grammar/grammar-util.ts
@@ -321,7 +321,7 @@ export function getRuleType(rule: ast.AbstractRule | undefined): string {
 }
 
 export function getEntryRule(grammar: ast.Grammar): ast.ParserRule | undefined {
-    return grammar.rules.find(e => ast.isParserRule(e)) as ast.ParserRule;
+    return grammar.rules.find(e => ast.isParserRule(e) && e.entry) as ast.ParserRule;
 }
 
 export function loadGrammar(json: string): ast.Grammar {

diff --git a/packages/langium/src/grammar/langium-grammar-code-actions.ts b/packages/langium/src/grammar/langium-grammar-code-actions.ts
@@ -38,6 +38,8 @@ export class LangiumGrammarCodeActionProvider implements CodeActionProvider {
                 return this.fixHiddenTerminals(diagnostic, document);
             case IssueCodes.UseRegexTokens:
                 return this.fixRegexTokens(diagnostic, document);
+            case IssueCodes.MakeRuleEntry:
+                return this.addEntryKeyword(diagnostic, document);
             default:
                 return undefined;
         }
@@ -67,6 +69,23 @@ export class LangiumGrammarCodeActionProvider implements CodeActionProvider {
         };
     }
 
+    private addEntryKeyword(diagnostic: Diagnostic, document: LangiumDocument): CodeAction | undefined {
+        return {
+            title: 'Add entry keyword',
+            kind: CodeActionKind.QuickFix,
+            diagnostics: [diagnostic],
+            isPreferred: true,
+            edit: {
+                changes: {
+                    [document.textDocument.uri]: [{
+                        range: {start: diagnostic.range.start, end: diagnostic.range.start},
+                        newText: 'entry '
+                    }]
+                }
+            }
+        };
+    }
+
     private fixRegexTokens(diagnostic: Diagnostic, document: LangiumDocument): CodeAction | undefined {
         const offset = document.textDocument.offsetAt(diagnostic.range.start);
         const rootCst = document.parseResult.value.$cstNode;

diff --git a/packages/langium/src/grammar/langium-grammar-validator.ts b/packages/langium/src/grammar/langium-grammar-validator.ts
@@ -33,7 +33,7 @@ export class LangiumGrammarValidationRegistry extends ValidationRegistry {
             UnorderedGroup: validator.checkUnorderedGroup,
             Grammar: [
                 validator.checkGrammarName,
-                validator.checkFirstGrammarRule,
+                validator.checkEntryGrammarRule,
                 validator.checkUniqueRuleName,
                 validator.checkGrammarHiddenTokens,
                 validator.checkGrammarForUnusedRules
@@ -52,6 +52,7 @@ export namespace IssueCodes {
     export const RuleNameUppercase = 'rule-name-uppercase';
     export const HiddenGrammarTokens = 'hidden-grammar-tokens';
     export const UseRegexTokens = 'use-regex-tokens';
+    export const MakeRuleEntry = 'entry-rule-token-syntax';
 }
 
 export class LangiumGrammarValidator {
@@ -71,16 +72,19 @@ export class LangiumGrammarValidator {
         }
     }
 
-    checkFirstGrammarRule(grammar: ast.Grammar, accept: ValidationAcceptor): void {
-        const firstRule = getEntryRule(grammar);
-        if (firstRule) {
-            if (isDataTypeRule(firstRule)) {
-                accept('error', 'The entry rule cannot be a data type rule.', { node: firstRule, property: 'name' });
-            } else if (firstRule.fragment) {
-                accept('error', 'The entry rule cannot be a fragment.', { node: firstRule, property: 'name' });
+    checkEntryGrammarRule(grammar: ast.Grammar, accept: ValidationAcceptor): void {
+        const entryRules = grammar.rules.filter(e => ast.isParserRule(e) && e.entry) as ast.ParserRule[];
+        if (entryRules.length === 0) {
+            const possibleEntryRule = grammar.rules.find(e => ast.isParserRule(e) && !isDataTypeRule(e));
+            if (possibleEntryRule) {
+                accept('error', 'The grammar is missing an entry parser rule. This rule can be an entry one.', { node: possibleEntryRule, property: 'name', code: IssueCodes.MakeRuleEntry });
+            } else {
+                accept('error', 'This grammar is missing an entry parser rule.', { node: grammar, property: 'name' });
             }
-        } else {
-            accept('error', 'This grammar is missing an entry parser rule.', { node: grammar, property: 'name' });
+        } else if (entryRules.length > 1) {
+            entryRules.forEach(rule => accept('error', 'The entry rule has to be unique.', { node: rule, property: 'name' }));
+        } else if (isDataTypeRule(entryRules[0])) {
+            accept('error', 'The entry rule cannot be a data type rule.', { node: entryRules[0], property: 'name' });
         }
     }
 

diff --git a/packages/langium/src/grammar/langium-grammar.langium b/packages/langium/src/grammar/langium-grammar.langium
@@ -8,7 +8,7 @@ terminal string: /"[^"]*"|'[^']*'/;
 hidden terminal ML_COMMENT: /\/\*[\s\S]*?\*\//;
 hidden terminal SL_COMMENT: /\/\/[^\n\r]*/;
 
-Grammar:
+entry Grammar:
 	'grammar' name=ID ('with' usedGrammars+=[Grammar|ID] (',' usedGrammars+=[Grammar|ID])*)?
 	(definesHiddenTokens?='hidden' '(' (hiddenTokens+=[AbstractRule|ID] (',' hiddenTokens+=[AbstractRule|ID])*)? ')')?
 	metamodelDeclarations+=AbstractMetamodelDeclaration*
@@ -31,7 +31,7 @@ Annotation:
 
 ParserRule :
 	(
-	  ^fragment?='fragment' RuleNameAndParams (wildcard?='*' | ('returns' type=ID)?)
+	  (^entry?='entry' | ^fragment?='fragment') RuleNameAndParams (wildcard?='*' | ('returns' type=ID)?)
 	| RuleNameAndParams ('returns' type=ID)?
 	)
 	(definesHiddenTokens?='hidden' '(' (hiddenTokens+=[AbstractRule|ID] (',' hiddenTokens+=[AbstractRule|ID])*)? ')')? ':'

diff --git a/packages/langium/src/parser/langium-parser-builder.ts b/packages/langium/src/parser/langium-parser-builder.ts
@@ -60,7 +60,6 @@ function getToken(ctx: ParserContext, name: string): TokenType {
 }
 
 function buildParserRules(parserContext: ParserContext, grammar: Grammar): void {
-    let first = true;
     for (const rule of stream(grammar.rules).filter(isParserRule)) {
         const ctx: RuleContext = {
             ...parserContext,
@@ -70,25 +69,12 @@ function buildParserRules(parserContext: ParserContext, grammar: Grammar): void
             many: 1,
             or: 1
         };
-        buildRule(ctx, rule, first);
-        first = false;
+        const method = (rule.entry ? ctx.parser.MAIN_RULE : ctx.parser.DEFINE_RULE).bind(ctx.parser);
+        const type = rule.fragment ? undefined : isDataTypeRule(rule) ? DatatypeSymbol : getTypeName(rule);
+        ctx.rules.set(rule.name, method(rule.name, type, buildRuleContent(ctx, rule)));
     }
 }
 
-function buildRule(ctx: RuleContext, rule: ParserRule, first: boolean): void {
-    const method = (first ? ctx.parser.MAIN_RULE : ctx.parser.DEFINE_RULE).bind(ctx.parser);
-    let type: string | symbol | undefined;
-    if (!rule.fragment) {
-        if (isDataTypeRule(rule)) {
-            type = DatatypeSymbol;
-        } else {
-            type = getTypeName(rule);
-        }
-    }
-
-    ctx.rules.set(rule.name, method(rule.name, type, buildRuleContent(ctx, rule)));
-}
-
 function buildRuleContent(ctx: RuleContext, rule: ParserRule): () => unknown {
     const method = buildElement(ctx, rule.alternatives);
     const arrays: string[] = [];