Execute langium-cli using a command to generate types definition

packages/langium-cli/package.json

@@ -35,7 +35,7 @@
   },
   "dependencies": {
     "chalk": "^4.1.2",
-    "commander": "^7.2.0",
+    "commander": "^8.0.0",
     "fs-extra": "^9.1.0",
     "jsonschema": "^1.4.0",
     "langium": "~0.5.0",

packages/langium-cli/src/generate.ts

@@ -21,12 +21,18 @@ import { getUserChoice, log } from './generator/util';
 import { getFilePath, LangiumConfig, LangiumLanguageConfig, RelativePath } from './package';
 import { validateParser } from './parser-validation';
 import chalk from 'chalk';
+import { generateTypesFile } from './generator/types-generator';
 
 export type GenerateOptions = {
     file?: string;
     watch: boolean
 }
 
+export type ExtractTypesOptions = {
+    grammar: string;
+    output?: string;
+}
+
 export type GeneratorResult = 'success' | 'failure';
 
 type GrammarElement = GrammarAST.AbstractRule | GrammarAST.Type | GrammarAST.Interface;
@@ -221,6 +227,23 @@ export async function generate(config: LangiumConfig, options: GenerateOptions):
     return 'success';
 }
 
+export async function generateTypes(options: ExtractTypesOptions): Promise<void> {
+    const absGrammarPath = URI.file(options.grammar);
+    const document = documents.getOrCreateDocument(absGrammarPath);
+    const allUris = eagerLoad(document);
+    await sharedServices.workspace.DocumentBuilder.update(allUris, []);
+    let grammarDoc;
+    for (const doc of documents.all) {
+        await sharedServices.workspace.DocumentBuilder.build([doc]);
+        grammarDoc = doc;
+    }
+    if (grammarDoc) {
+        const genTypes = generateTypesFile(grammarServices, [grammarDoc.parseResult.value as Grammar]);
+        await writeWithFail(path.join(path.resolve(options.grammar, '..'), options.output ?? 'types.langium'), genTypes, { watch: false });
+    }
+    return;
+}
+
 /**
  * Writes contents of a grammar for syntax highlighting to a file, logging any errors and continuing without throwing
  * @param grammar Grammar contents to write
@@ -265,7 +288,7 @@ async function mkdirWithFail(path: string, options: GenerateOptions): Promise<bo
     }
 }
 
-async function writeWithFail(path: string, content: string, options: GenerateOptions): Promise<void> {
+async function writeWithFail(path: string, content: string, options: { watch: boolean }): Promise<void> {
     try {
         await fs.writeFile(path, content);
     } catch (e) {

packages/langium-cli/src/generator/types-generator.ts

@@ -0,0 +1,49 @@
+/******************************************************************************
+ * Copyright 2022 TypeFox GmbH
+ * This program and the accompanying materials are made available under the
+ * terms of the MIT License, which is available in the project root.
+ ******************************************************************************/
+
+import { CompositeGeneratorNode, Grammar, LangiumServices, NL, processGeneratorNode } from 'langium';
+import { collectAst, distinctAndSorted, PropertyType } from 'langium/lib/grammar/type-system';
+import { LangiumGrammarGrammar } from 'langium/lib/grammar/generated/grammar';
+import { collectKeywords } from './util';
+
+export function generateTypesFile(services: LangiumServices, grammars: Grammar[]): string {
+    const astTypes = collectAst(services.shared.workspace.LangiumDocuments, grammars);
+    const fileNode = new CompositeGeneratorNode();
+    const reservedWords = new Set(collectKeywords(LangiumGrammarGrammar()));
+    astTypes.unions.filter((union) => !astTypes.interfaces.find((iface) =>
+        iface.name === union.name
+    )).forEach((union) => {
+        fileNode.append(`type ${escapeReservedWords(union.name, reservedWords)} = ${propertyTypesToString(union.union)};`);
+        fileNode.append(NL).append(NL);
+    });
+    astTypes.interfaces.forEach((iFace) => {
+        fileNode.append(`interface ${escapeReservedWords(iFace.name, reservedWords)}${iFace.interfaceSuperTypes.length > 0 ? (' extends ' + Array.from(iFace.interfaceSuperTypes).join(', ')) : ''} {`);
+        fileNode.append(NL);
+        fileNode.indent((body) => {
+            iFace.properties.forEach(property =>
+                body.append(`${escapeReservedWords(property.name, reservedWords)}${property.optional ? '?' : ''}: ${propertyTypesToString(property.typeAlternatives)}`).append(NL)
+            );
+        });
+        fileNode.append('}').append(NL).append(NL);
+    }
+    );
+    return processGeneratorNode(fileNode);
+}
+
+function propertyTypesToString(alternatives: PropertyType[]): string {
+    return distinctAndSorted(alternatives.map(typePropertyToString)).join(' | ');
+}
+
+function typePropertyToString(propertyType: PropertyType): string {
+    let res = distinctAndSorted(propertyType.types).join(' | ');
+    res = propertyType.reference ? `@${res}` : res;
+    res = propertyType.array ? `${res}[]` : res;
+    return res;
+}
+
+function escapeReservedWords(name: string, reserved: Set<string>): string {
+    return reserved.has(name) ? `^${name}` : name;
+}

packages/langium-cli/src/generator/util.ts

@@ -8,11 +8,10 @@ import { CompositeGeneratorNode, GeneratorNode, getAllReachableRules, Grammar, G
 import fs from 'fs-extra';
 import path from 'path';
 import * as readline from 'readline';
-import type { GenerateOptions } from '../generate';
 import chalk from 'chalk';
 
 //eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function log(level: 'log' | 'warn' | 'error', options: GenerateOptions, message: string, ...args: any[]): void {
+export function log(level: 'log' | 'warn' | 'error', options: { watch: boolean }, message: string, ...args: any[]): void {
     if (options.watch) {
         console[level](getTime() + message, ...args);
     } else {

packages/langium-cli/src/langium.ts

@@ -8,7 +8,7 @@ import chalk from 'chalk';
 import fs from 'fs-extra';
 import { Command } from 'commander';
 import { validate } from 'jsonschema';
-import { generate, GenerateOptions, GeneratorResult } from './generate';
+import { ExtractTypesOptions, generate, GenerateOptions, generateTypes, GeneratorResult } from './generate';
 import { cliVersion, elapsedTime, getTime, log, schema } from './generator/util';
 import { LangiumConfig, loadConfigs, RelativePath } from './package';
 import path from 'path';
@@ -27,6 +27,17 @@ program
             process.exit(1);
         });
     });
+program.command('extract-types')
+    .argument('<file>', 'the langium grammar file to generate types for')
+    .option('-o, --output <file>', 'output file name', 'types.langium')
+    .action((file, options: ExtractTypesOptions) => {
+        options.grammar = file;
+        generateTypes(options).catch(err => {
+            console.error(err);
+            process.exit(1);
+        });
+    })
+    .action;
 
 program.parse(process.argv);
 

packages/langium-cli/test/generator/types-generator.test.ts

@@ -0,0 +1,109 @@
+/******************************************************************************
+ * Copyright 2022 TypeFox GmbH
+ * This program and the accompanying materials are made available under the
+ * terms of the MIT License, which is available in the project root.
+ ******************************************************************************/
+
+import { createLangiumGrammarServices, EmptyFileSystem, Grammar } from 'langium';
+import { parseHelper } from 'langium/test';
+import { generateTypesFile } from '../../src/generator/types-generator';
+
+const { grammar } = createLangiumGrammarServices(EmptyFileSystem);
+
+describe('Types generator', () => {
+
+    test('should generate types file', async () => {
+        const result = (await parseHelper<Grammar>(grammar)(TEST_GRAMMAR)).parseResult;
+        const typesFileContent = generateTypesFile(grammar, [result.value]);
+        expect(typesFileContent).toMatch(EXPECTED_TYPES);
+    });
+
+});
+
+const EXPECTED_TYPES =
+    `type AbstractDefinition = DeclaredParameter | Definition;
+
+type Expression = BinaryExpression | FunctionCall | NumberLiteral;
+
+type Statement = Definition | Evaluation;
+
+interface BinaryExpression {
+    left: Expression
+    operator: '*' | '+' | '-' | '/'
+    right: Expression
+}
+
+interface DeclaredParameter {
+    name: string
+}
+
+interface Definition {
+    name: string
+    args?: DeclaredParameter[]
+    expr: Expression
+}
+
+interface Evaluation {
+    expression: Expression
+}
+
+interface FunctionCall {
+    func: @AbstractDefinition
+    args?: Expression[]
+}
+
+interface Module {
+    name: string
+    statements?: Statement[]
+}
+
+interface NumberLiteral {
+    value: number
+}
+
+`;
+
+const TEST_GRAMMAR =
+    `
+grammar Arithmetics
+
+entry Module:
+    'module' name=ID
+    (statements+=Statement)*;
+
+Statement:
+    Definition | Evaluation;
+
+Definition:
+    'def' name=ID ('(' args+=DeclaredParameter (',' args+=DeclaredParameter)* ')')?
+    ':' expr=Expression ';';
+
+DeclaredParameter:
+    name=ID;
+
+type AbstractDefinition = Definition | DeclaredParameter;
+
+Evaluation:
+    expression=Expression ';';
+
+Expression:
+    Addition;
+
+Addition infers Expression:
+    Multiplication ({infer BinaryExpression.left=current} operator=('+' | '-') right=Multiplication)*;
+
+Multiplication infers Expression:
+    PrimaryExpression ({infer BinaryExpression.left=current} operator=('*' | '/') right=PrimaryExpression)*;
+
+PrimaryExpression infers Expression:
+    '(' Expression ')' |
+    {infer NumberLiteral} value=NUMBER |
+    {infer FunctionCall} func=[AbstractDefinition] ('(' args+=Expression (',' args+=Expression)* ')')?;
+
+hidden terminal WS: /\\s+/;
+terminal ID: /[_a-zA-Z][\\w_]*/;
+terminal NUMBER returns number: /[0-9]+(\\.[0-9]*)?/;
+
+hidden terminal ML_COMMENT: /\\/\\*[\\s\\S]*?\\*\\//;
+hidden terminal SL_COMMENT: /\\/\\/[^\\n\\r]*/;
+`;

packages/langium-vscode/package.json

@@ -47,10 +47,28 @@
           "description": "Specifies the exclusion patterns during initial workspace indexing. You will need to reload your extension afterwards."
         }
       }
+    },
+    "commands": [
+			{
+				"category": "Developer",
+				"command": "langium-vscode.generate-types",
+				"title": "Generate Langium Types Definition",
+        "enablement": "editorLangId == langium"
+			}
+		],
+    "menus": {
+      "editor/context": [
+        {
+          "command": "langium-vscode.generate-types",
+          "when": "editorLangId == langium",
+          "group": "z_commands"
+        }
+      ]
     }
   },
   "activationEvents": [
-    "onLanguage:langium"
+    "onLanguage:langium",
+    "langium-vscode.generate-types"
   ],
   "main": "out/extension.js",
   "scripts": {