Improve generated ast.ts regarding multiple languages (#1979)

* split the content inside the ast.ts for multiple-language-projects * added validations to make names of grammars unique regarding: other grammar's names, names of types/rules * mix and sort type definitions derived from unions and interfaces

Author: JohannesMeierSE

examples/arithmetics/src/language-server/generated/ast.ts

@@ -43,26 +43,6 @@ export function isAbstractDefinition(item: unknown): item is AbstractDefinition
  return reflection.isInstance(item, AbstractDefinition.$type);
 }
 
-export type Expression = BinaryExpression | FunctionCall | NumberLiteral;
-
-export const Expression = {
- $type: 'Expression'
-} as const;
-
-export function isExpression(item: unknown): item is Expression {
- return reflection.isInstance(item, Expression.$type);
-}
-
-export type Statement = Definition | Evaluation;
-
-export const Statement = {
- $type: 'Statement'
-} as const;
-
-export function isStatement(item: unknown): item is Statement {
- return reflection.isInstance(item, Statement.$type);
-}
-
 export interface BinaryExpression extends langium.AstNode {
  readonly $container: BinaryExpression | Definition | Evaluation | FunctionCall;
  readonly $type: 'BinaryExpression';
@@ -131,6 +111,16 @@ export function isEvaluation(item: unknown): item is Evaluation {
  return reflection.isInstance(item, Evaluation.$type);
 }
 
+export type Expression = BinaryExpression | FunctionCall | NumberLiteral;
+
+export const Expression = {
+ $type: 'Expression'
+} as const;
+
+export function isExpression(item: unknown): item is Expression {
+ return reflection.isInstance(item, Expression.$type);
+}
+
 export interface FunctionCall extends langium.AstNode {
  readonly $container: BinaryExpression | Definition | Evaluation | FunctionCall;
  readonly $type: 'FunctionCall';
@@ -179,6 +169,16 @@ export function isNumberLiteral(item: unknown): item is NumberLiteral {
  return reflection.isInstance(item, NumberLiteral.$type);
 }
 
+export type Statement = Definition | Evaluation;
+
+export const Statement = {
+ $type: 'Statement'
+} as const;
+
+export function isStatement(item: unknown): item is Statement {
+ return reflection.isInstance(item, Statement.$type);
+}
+
 export type ArithmeticsAstType = {
  AbstractDefinition: AbstractDefinition
  BinaryExpression: BinaryExpression

examples/domainmodel/src/language-server/generated/ast.ts

@@ -38,22 +38,6 @@ export function isAbstractElement(item: unknown): item is AbstractElement {
  return reflection.isInstance(item, AbstractElement.$type);
 }
 
-export type QualifiedName = string;
-
-export function isQualifiedName(item: unknown): item is QualifiedName {
- return typeof item === 'string';
-}
-
-export type Type = DataType | Entity;
-
-export const Type = {
- $type: 'Type'
-} as const;
-
-export function isType(item: unknown): item is Type {
- return reflection.isInstance(item, Type.$type);
-}
-
 export interface DataType extends langium.AstNode {
  readonly $container: Domainmodel | PackageDeclaration;
  readonly $type: 'DataType';
@@ -138,6 +122,22 @@ export function isPackageDeclaration(item: unknown): item is PackageDeclaration
  return reflection.isInstance(item, PackageDeclaration.$type);
 }
 
+export type QualifiedName = string;
+
+export function isQualifiedName(item: unknown): item is QualifiedName {
+ return typeof item === 'string';
+}
+
+export type Type = DataType | Entity;
+
+export const Type = {
+ $type: 'Type'
+} as const;
+
+export function isType(item: unknown): item is Type {
+ return reflection.isInstance(item, Type.$type);
+}
+
 export type DomainModelAstType = {
  AbstractElement: AbstractElement
  DataType: DataType

examples/requirements/src/language-server/generated/ast.ts

@@ -6,31 +6,95 @@
 /* eslint-disable */
 import * as langium from 'langium';
 
+/** Contains the reachable terminals & keywords and all available types of the 'Requirements' language. */
+export namespace Requirements {
+
+ export const Terminals = {
+ WS: /\s+/,
+ ID: /[_a-zA-Z][\w_]*/,
+ STRING: /"(\\.|[^"\\])*"|'(\\.|[^'\\])*'/,
+ ML_COMMENT: /\/\*[\s\S]*?\*\//,
+ SL_COMMENT: /\/\/[^\n\r]*/,
+ };
+
+ export type TerminalNames = keyof typeof Terminals;
+
+ export type KeywordNames =
+ | ","
+ | ":"
+ | "applicable"
+ | "contact"
+ | "environment"
+ | "for"
+ | "req";
+
+ export type TokenNames = TerminalNames | KeywordNames;
+
+ export type AstType = {
+ Contact: Contact
+ Environment: Environment
+ Requirement: Requirement
+ RequirementModel: RequirementModel
+ }
+
+}
+
+/** Contains the reachable terminals & keywords and all available types of the 'Tests' language. */
+export namespace Tests {
+
+ export const Terminals = {
+ WS: /\s+/,
+ ID: /[_a-zA-Z][\w_]*/,
+ STRING: /"(\\.|[^"\\])*"|'(\\.|[^'\\])*'/,
+ ML_COMMENT: /\/\*[\s\S]*?\*\//,
+ SL_COMMENT: /\/\/[^\n\r]*/,
+ };
+
+ export type TerminalNames = keyof typeof Terminals;
+
+ export type KeywordNames =
+ | ","
+ | ":"
+ | "="
+ | "applicable"
+ | "contact"
+ | "for"
+ | "testFile"
+ | "tests"
+ | "tst";
+
+ export type TokenNames = TerminalNames | KeywordNames;
+
+ export type AstType = {
+ Contact: Contact
+ Environment: Environment
+ Requirement: Requirement
+ RequirementModel: RequirementModel
+ Test: Test
+ TestModel: TestModel
+ }
+
+}
+
+
+// the terminals, keywords and types of the whole 'RequirementsAndTests' project
+
 export const RequirementsAndTestsTerminals = {
- WS: /\s+/,
- ID: /[_a-zA-Z][\w_]*/,
- STRING: /"(\\.|[^"\\])*"|'(\\.|[^'\\])*'/,
- ML_COMMENT: /\/\*[\s\S]*?\*\//,
- SL_COMMENT: /\/\/[^\n\r]*/,
+ ...Requirements.Terminals,
+ ...Tests.Terminals,
 };
 
 export type RequirementsAndTestsTerminalNames = keyof typeof RequirementsAndTestsTerminals;
 
-export type RequirementsAndTestsKeywordNames =
- | ","
- | ":"
- | "="
- | "applicable"
- | "contact"
- | "environment"
- | "for"
- | "req"
- | "testFile"
- | "tests"
- | "tst";
+export type RequirementsAndTestsKeywordNames = Requirements.KeywordNames | Tests.KeywordNames;
 
 export type RequirementsAndTestsTokenNames = RequirementsAndTestsTerminalNames | RequirementsAndTestsKeywordNames;
 
+export type RequirementsAndTestsAstType = Requirements.AstType & Tests.AstType
+
+
+// all type definitions of the the whole 'RequirementsAndTests' project
+
 export interface Contact extends langium.AstNode {
  readonly $container: RequirementModel | TestModel;
  readonly $type: 'Contact';
@@ -137,15 +201,6 @@ export function isTestModel(item: unknown): item is TestModel {
  return reflection.isInstance(item, TestModel.$type);
 }
 
-export type RequirementsAndTestsAstType = {
- Contact: Contact
- Environment: Environment
- Requirement: Requirement
- RequirementModel: RequirementModel
- Test: Test
- TestModel: TestModel
-}
-
 export class RequirementsAndTestsAstReflection extends langium.AbstractAstReflection {
  override readonly types = {
  Contact: {

examples/statemachine/src/cli/cli.ts

@@ -8,7 +8,7 @@ import chalk from 'chalk';
 import { Command } from 'commander';
 import { NodeFileSystem } from 'langium/node';
 import type { Statemachine } from '../language-server/generated/ast.js';
-import { StatemachineLanguageMetaData } from '../language-server/generated/module.js';
+import { StatemachineModelLanguageMetaData } from '../language-server/generated/module.js';
 import { createStatemachineServices } from '../language-server/statemachine-module.js';
 import { extractAstNode } from './cli-util.js';
 import { generateCpp } from './generator.js';
@@ -18,7 +18,7 @@ import * as path from 'node:path';
 
 export const generateAction = async (fileName: string, opts: GenerateOptions): Promise<void> => {
  const services = createStatemachineServices(NodeFileSystem).statemachine;
- const statemachine = await extractAstNode<Statemachine>(fileName, StatemachineLanguageMetaData.fileExtensions, services);
+ const statemachine = await extractAstNode<Statemachine>(fileName, StatemachineModelLanguageMetaData.fileExtensions, services);
  const generatedFilePath = generateCpp(statemachine, fileName, opts.destination);
  console.log(chalk.green(`C++ code generated successfully: ${generatedFilePath}`));
 };
@@ -38,9 +38,9 @@ program.version(JSON.parse(packageContent).version);
 
 program
  .command('generate')
- .argument('<file>', `possible file extensions: ${StatemachineLanguageMetaData.fileExtensions.join(', ')}`)
+ .argument('<file>', `possible file extensions: ${StatemachineModelLanguageMetaData.fileExtensions.join(', ')}`)
  .option('-d, --destination <dir>', 'destination directory of generating')
  .description('generates a C++ CLI to walk over states')
  .action(generateAction);
 
-program.parse(process.argv);
+program.parse(process.argv);

examples/statemachine/src/language-server/generated/grammar.ts

@@ -6,11 +6,11 @@
 import type { Grammar } from 'langium';
 import { loadGrammarFromJson } from 'langium';
 
-let loadedStatemachineGrammar: Grammar | undefined;
-export const StatemachineGrammar = (): Grammar => loadedStatemachineGrammar ?? (loadedStatemachineGrammar = loadGrammarFromJson(`{
+let loadedStatemachineModelGrammar: Grammar | undefined;
+export const StatemachineModelGrammar = (): Grammar => loadedStatemachineModelGrammar ?? (loadedStatemachineModelGrammar = loadGrammarFromJson(`{
  "$type": "Grammar",
  "isDeclared": true,
- "name": "Statemachine",
+ "name": "StatemachineModel",
  "rules": [
  {
  "$type": "ParserRule",

examples/statemachine/src/language-server/generated/module.ts

@@ -5,9 +5,9 @@
 
 import type { LangiumSharedCoreServices, LangiumCoreServices, LangiumGeneratedCoreServices, LangiumGeneratedSharedCoreServices, LanguageMetaData, Module } from 'langium';
 import { StatemachineAstReflection } from './ast.js';
-import { StatemachineGrammar } from './grammar.js';
+import { StatemachineModelGrammar } from './grammar.js';
 
-export const StatemachineLanguageMetaData = {
+export const StatemachineModelLanguageMetaData = {
  languageId: 'statemachine',
  fileExtensions: ['.statemachine'],
  caseInsensitive: false,
@@ -18,8 +18,8 @@ export const StatemachineGeneratedSharedModule: Module<LangiumSharedCoreServices
  AstReflection: () => new StatemachineAstReflection()
 };
 
-export const StatemachineGeneratedModule: Module<LangiumCoreServices, LangiumGeneratedCoreServices> = {
- Grammar: () => StatemachineGrammar(),
- LanguageMetaData: () => StatemachineLanguageMetaData,
+export const StatemachineModelGeneratedModule: Module<LangiumCoreServices, LangiumGeneratedCoreServices> = {
+ Grammar: () => StatemachineModelGrammar(),
+ LanguageMetaData: () => StatemachineModelLanguageMetaData,
  parser: {}
 };

examples/statemachine/src/language-server/statemachine-module.ts

@@ -7,7 +7,7 @@
 import { type Module, inject } from 'langium';
 import type { LangiumServices, LangiumSharedServices, PartialLangiumServices } from 'langium/lsp';
 import { createDefaultModule, createDefaultSharedModule, type DefaultSharedModuleContext } from 'langium/lsp';
-import { StatemachineGeneratedModule, StatemachineGeneratedSharedModule } from './generated/module.js';
+import { StatemachineGeneratedSharedModule, StatemachineModelGeneratedModule } from './generated/module.js';
 import { StatemachineValidator, registerValidationChecks } from './statemachine-validator.js';
 
 /**
@@ -61,7 +61,7 @@ export function createStatemachineServices(context: DefaultSharedModuleContext):
  );
  const statemachine = inject(
  createDefaultModule({ shared }),
- StatemachineGeneratedModule,
+ StatemachineModelGeneratedModule,
  StatemachineModule
  );
  shared.ServiceRegistry.register(statemachine);

examples/statemachine/src/language-server/statemachine.langium

@@ -1,4 +1,4 @@
-grammar Statemachine
+grammar StatemachineModel
 
 /** A textual representation of a state machine */
 entry Statemachine: