AbstractTypes need to include InferredTypes (#1328)

* AbstractTypes need to include InferredTypes, since cross-references might use InferredTypes as their types
* simplify some type declarations, since InferredType is an AbstractType now
* use InferredType as type for implicitly and explicitly inferred types in scopes, improved comments
* an Action is no AbstractType anymore
    - since Actions either reuse already declared types or contribute a new type with an InferredType
    - and InferredTypes are AbstractTypes now
* fixed remaining problem: export the explicitly inferred type of an action, not the action itself
* fixed the identification of the name-assignment for inferred types used in cross-references
    - this bug was there even before changing the way how Actions and InferredTypes are used as AbstractTypes!

Author: JohannesMeierSE

packages/langium/src/grammar/generated/grammar.ts

@@ -3907,13 +3907,13 @@ export const LangiumGrammarGrammar = (): Grammar => loadedLangiumGrammarGrammar
           {
             "$type": "SimpleType",
             "typeRef": {
-              "$ref": "#/rules@27/definition/elements@0"
+              "$ref": "#/rules@17"
             }
           },
           {
             "$type": "SimpleType",
             "typeRef": {
-              "$ref": "#/rules@17"
+              "$ref": "#/rules@18"
             }
           }
         ]

packages/langium/src/grammar/internal-grammar-util.ts

@@ -64,7 +64,7 @@ function isStringTypeInternal(type: ast.AbstractType | ast.TypeDefinition, visit
     return false;
 }
 
-export function getTypeNameWithoutError(type?: ast.AbstractType | ast.InferredType): string | undefined {
+export function getTypeNameWithoutError(type?: ast.AbstractType | ast.Action): string | undefined {
     if (!type) {
         return undefined;
     }

packages/langium/src/grammar/langium-grammar.langium

@@ -55,7 +55,7 @@ SimpleType infers TypeDefinition:
 PrimitiveType returns string:
     'string' | 'number' | 'boolean' | 'Date' | 'bigint';
 
-type AbstractType = Interface | Type | Action | ParserRule;
+type AbstractType = Interface | Type | ParserRule | InferredType;
 
 Type:
     'type' name=ID '=' type=TypeDefinition ';'?;

packages/langium/src/grammar/references/grammar-scope.ts

@@ -17,9 +17,8 @@ import { DefaultScopeProvider } from '../../references/scope-provider.js';
 import { findRootNode, getContainerOfType, getDocument, streamAllContents } from '../../utils/ast-utils.js';
 import { toDocumentSegment } from '../../utils/cst-utils.js';
 import { stream } from '../../utils/stream.js';
-import { AbstractType, Interface, isAction, isGrammar, isParserRule, isReturnType, Type } from '../../languages/generated/ast.js';
+import { AbstractType, InferredType, Interface, isAction, isGrammar, isParserRule, isReturnType, Type } from '../../languages/generated/ast.js';
 import { resolveImportUri } from '../internal-grammar-util.js';
-import { getActionType } from '../../utils/grammar-utils.js';
 
 export class LangiumGrammarScopeProvider extends DefaultScopeProvider {
 
@@ -46,7 +45,7 @@ export class LangiumGrammarScopeProvider extends DefaultScopeProvider {
         if (precomputed && rootNode) {
             const allDescriptions = precomputed.get(rootNode);
             if (allDescriptions.length > 0) {
-                localScope = stream(allDescriptions).filter(des => des.type === Interface || des.type === Type);
+                localScope = stream(allDescriptions).filter(des => des.type === Interface || des.type === Type || des.type === InferredType);
             }
         }
 
@@ -67,7 +66,7 @@ export class LangiumGrammarScopeProvider extends DefaultScopeProvider {
         this.gatherImports(grammar, importedUris);
         let importedElements = this.indexManager.allElements(referenceType, importedUris);
         if (referenceType === AbstractType) {
-            importedElements = importedElements.filter(des => des.type === Interface || des.type === Type);
+            importedElements = importedElements.filter(des => des.type === Interface || des.type === Type || des.type === InferredType);
         }
         return new MapScope(importedElements);
     }
@@ -99,60 +98,74 @@ export class LangiumGrammarScopeComputation extends DefaultScopeComputation {
     }
 
     protected override exportNode(node: AstNode, exports: AstNodeDescription[], document: LangiumDocument): void {
+        // this function is called in order to export nodes to the GLOBAL scope
+
+        /* Among others, TYPES need to be exported.
+         * There are three ways to define types:
+         * - explicit "type" declarations
+         * - explicit "interface" declarations
+         * - "inferred types", which can be distinguished into ...
+         *     - inferred types with explicitly declared names, i.e. parser rules with "infers", actions with "infer"
+         *       Note, that multiple explicitly inferred types might have the same name! Cross-references to such types are resolved to the first declaration.
+         *     - implicitly inferred types, i.e. parser rules without "infers" and without "returns",
+         *       which implicitly declare a type with the same name as the parser rule
+         *       Note, that implicitly inferred types are unique, since names of parser rules must be unique.
+         */
+
+        // export the top-level elements: parser rules, terminal rules, types, interfaces
         super.exportNode(node, exports, document);
+
+        // additionally, export inferred types:
         if (isParserRule(node)) {
             if (!node.returnType && !node.dataType) {
-                // Export inferred rule type as interface
+                // Export implicitly and explicitly inferred type from parser rule
                 const typeNode = node.inferredType ?? node;
-                exports.push(this.createInterfaceDescription(typeNode, typeNode.name, document));
+                exports.push(this.createInferredTypeDescription(typeNode, typeNode.name, document));
             }
             streamAllContents(node).forEach(childNode => {
                 if (isAction(childNode) && childNode.inferredType) {
-                    const typeName = getActionType(childNode);
-                    if (typeName) {
-                        // Export inferred action type as interface
-                        exports.push(this.createInterfaceDescription(childNode, typeName, document));
-                    }
+                    // Export explicitly inferred type from action
+                    exports.push(this.createInferredTypeDescription(childNode.inferredType, childNode.inferredType.name, document));
                 }
             });
         }
     }
 
     protected override processNode(node: AstNode, document: LangiumDocument, scopes: PrecomputedScopes): void {
-        if (isReturnType(node)) return;
+        // for the precompution of the local scope
+        if (isReturnType(node)) {
+            return;
+        }
         this.processTypeNode(node, document, scopes);
         this.processActionNode(node, document, scopes);
         super.processNode(node, document, scopes);
     }
 
     /**
-     * Add synthetic Interface in case of explicitly or implicitly inferred type:<br>
+     * Add synthetic type into the scope in case of explicitly or implicitly inferred type:<br>
      * cases: `ParserRule: ...;` or `ParserRule infers Type: ...;`
      */
     protected processTypeNode(node: AstNode, document: LangiumDocument, scopes: PrecomputedScopes): void {
         const container = node.$container;
         if (container && isParserRule(node) && !node.returnType && !node.dataType) {
             const typeNode = node.inferredType ?? node;
-            scopes.add(container, this.createInterfaceDescription(typeNode, typeNode.name, document));
+            scopes.add(container, this.createInferredTypeDescription(typeNode, typeNode.name, document));
         }
     }
 
     /**
-     * Add synthetic Interface in case of explicitly inferred type:
+     * Add synthetic type into the scope in case of explicitly inferred type:
      *
      * case: `{infer Action}`
      */
     protected processActionNode(node: AstNode, document: LangiumDocument, scopes: PrecomputedScopes): void {
         const container = findRootNode(node);
         if (container && isAction(node) && node.inferredType) {
-            const typeName = getActionType(node);
-            if (typeName) {
-                scopes.add(container, this.createInterfaceDescription(node, typeName, document));
-            }
+            scopes.add(container, this.createInferredTypeDescription(node.inferredType, node.inferredType.name, document));
         }
     }
 
-    protected createInterfaceDescription(node: AstNode, name: string, document: LangiumDocument = getDocument(node)): AstNodeDescription {
+    protected createInferredTypeDescription(node: AstNode, name: string, document: LangiumDocument = getDocument(node)): AstNodeDescription {
         let nameNodeSegment: DocumentSegment | undefined;
         const nameSegmentGetter = () => nameNodeSegment ??= toDocumentSegment(this.nameProvider.getNameNode(node) ?? node.$cstNode);
         return {
@@ -162,7 +175,7 @@ export class LangiumGrammarScopeComputation extends DefaultScopeComputation {
                 return nameSegmentGetter();
             },
             selectionSegment: toDocumentSegment(node.$cstNode),
-            type: 'Interface',
+            type: InferredType,
             documentUri: document.uri,
             path: this.astNodeLocator.getAstNodePath(node)
         };

packages/langium/src/grammar/validation/validator.ts

@@ -372,7 +372,7 @@ export class LangiumGrammarValidator {
         }
     }
 
-    private getActionType(rule: ast.Action): ast.AbstractType | ast.InferredType | undefined {
+    private getActionType(rule: ast.Action): ast.AbstractType | undefined {
         if (rule.type) {
             return rule.type?.ref;
         } else if (rule.inferredType) {

packages/langium/src/languages/generated/ast.ts

@@ -25,7 +25,7 @@ export function isAbstractRule(item: unknown): item is AbstractRule {
     return reflection.isInstance(item, AbstractRule);
 }
 
-export type AbstractType = Action | Interface | ParserRule | Type;
+export type AbstractType = InferredType | Interface | ParserRule | Type;
 
 export const AbstractType = 'AbstractType';
 
@@ -643,9 +643,7 @@ export class LangiumGrammarAstReflection extends AbstractAstReflection {
 
     protected override computeIsSubtype(subtype: string, supertype: string): boolean {
         switch (subtype) {
-            case Action: {
-                return this.isSubtype(AbstractElement, supertype) || this.isSubtype(AbstractType, supertype);
-            }
+            case Action:
             case Alternatives:
             case Assignment:
             case CharacterRange:
@@ -684,6 +682,7 @@ export class LangiumGrammarAstReflection extends AbstractAstReflection {
             case ParameterReference: {
                 return this.isSubtype(Condition, supertype);
             }
+            case InferredType:
             case Interface:
             case Type: {
                 return this.isSubtype(AbstractType, supertype);

packages/langium/src/utils/grammar-utils.ts

@@ -4,8 +4,9 @@
  * terms of the MIT License, which is available in the project root.
  ******************************************************************************/
 
-import type { AstNode, CstNode } from '../syntax-tree.js';
+import { assertUnreachable } from '../utils/errors.js';
 import * as ast from '../languages/generated/ast.js';
+import type { AstNode, CstNode } from '../syntax-tree.js';
 import { isCompositeCstNode } from '../syntax-tree.js';
 import { getContainerOfType, streamAllContents } from './ast-utils.js';
 import { streamCst } from './cst-utils.js';
@@ -234,29 +235,41 @@ export function findAssignment(cstNode: CstNode): ast.Assignment | undefined {
  * from a parser rule, and that rule must contain an assignment to the `name` property. In all other cases,
  * this function returns `undefined`.
  */
-export function findNameAssignment(type: ast.AbstractType | ast.InferredType): ast.Assignment | undefined {
-    if (ast.isInferredType(type)) {
-        // inferred type is unexpected, extract AbstractType first
-        type = type.$container;
+export function findNameAssignment(type: ast.AbstractType): ast.Assignment | undefined {
+    let startNode: AstNode = type;
+    if (ast.isInferredType(startNode)) {
+        // for inferred types, the location to start searching for the name-assignment is different
+        if (ast.isAction(startNode.$container)) {
+            // a type which is explicitly inferred by an action: investigate the sibbling of the Action node, i.e. start searching at the Action's parent
+            startNode = startNode.$container.$container!;
+        } else if (ast.isParserRule(startNode.$container)) {
+            // investigate the parser rule with the explicitly inferred type
+            startNode = startNode.$container;
+        } else {
+            assertUnreachable(startNode.$container);
+        }
     }
-    return findNameAssignmentInternal(type, new Map());
+    return findNameAssignmentInternal(type, startNode, new Map());
 }
 
-function findNameAssignmentInternal(type: ast.AbstractType, cache: Map<ast.AbstractType, ast.Assignment | undefined>): ast.Assignment | undefined {
+function findNameAssignmentInternal(type: ast.AbstractType, startNode: AstNode, cache: Map<ast.AbstractType, ast.Assignment | undefined>): ast.Assignment | undefined {
+    // the cache is only required to prevent infinite loops
     function go(node: AstNode, refType: ast.AbstractType): ast.Assignment | undefined {
         let childAssignment: ast.Assignment | undefined = undefined;
         const parentAssignment = getContainerOfType(node, ast.isAssignment);
         // No parent assignment implies unassigned rule call
         if (!parentAssignment) {
-            childAssignment = findNameAssignmentInternal(refType, cache);
+            childAssignment = findNameAssignmentInternal(refType, refType, cache);
         }
         cache.set(type, childAssignment);
         return childAssignment;
     }
 
-    if (cache.has(type)) return cache.get(type);
+    if (cache.has(type)) {
+        return cache.get(type);
+    }
     cache.set(type, undefined);
-    for (const node of streamAllContents(type)) {
+    for (const node of streamAllContents(startNode)) {
         if (ast.isAssignment(node) && node.feature.toLowerCase() === 'name') {
             cache.set(type, node);
             return node;
@@ -395,7 +408,7 @@ export function getExplicitRuleType(rule: ast.ParserRule): string | undefined {
     return undefined;
 }
 
-export function getTypeName(type: ast.AbstractType | ast.InferredType): string {
+export function getTypeName(type: ast.AbstractType | ast.Action): string {
     if (ast.isParserRule(type)) {
         return isDataTypeRule(type) ? type.name : getExplicitRuleType(type) ?? type.name;
     } else if (ast.isInterface(type) || ast.isType(type) || ast.isReturnType(type)) {
@@ -412,7 +425,7 @@ export function getTypeName(type: ast.AbstractType | ast.InferredType): string {
 }
 
 export function getActionType(action: ast.Action): string | undefined {
-    if(action.inferredType) {
+    if (action.inferredType) {
         return action.inferredType.name;
     } else if (action.type?.ref) {
         return getTypeName(action.type.ref);

packages/langium/test/grammar/grammar-validator.test.ts

@@ -252,6 +252,42 @@ describe('Check Rule Fragment Validation', () => {
     });
 });
 
+describe('Check cross-references to inferred types', () => {
+    test('infer after the parser rules names', async () => {
+        const validationResult = await validate(`
+        grammar HelloWorld
+
+        entry Model: a+=A*;
+
+        A infers B: 'a' name=ID (otherA=[B])?; // works
+
+        hidden terminal WS: /\\s+/;
+        terminal ID: /[a-zA-Z_][a-zA-Z0-9_]*/;
+        `.trim());
+        expectNoIssues(validationResult);
+        // expect(validationResult.diagnostics).toHaveLength(1);
+        // expect(validationResult.diagnostics[0].message).toBe('Cannot infer terminal or data type rule for cross-reference.');
+        // expectError(validationResult, 'Cannot use rule fragments in types.');
+    });
+
+    test('infer in the parser rules body', async () => {
+        const validationResult = await validate(`
+        grammar HelloWorld
+
+        entry Model: a+=A*;
+
+        A: {infer B} 'a' name=ID (otherA=[B])?;
+
+        hidden terminal WS: /\\s+/;
+        terminal ID: /[a-zA-Z_][a-zA-Z0-9_]*/;
+        `.trim());
+        expectNoIssues(validationResult);
+        // expect(validationResult.diagnostics).toHaveLength(1);
+        // expect(validationResult.diagnostics[0].message).toBe('Cannot infer terminal or data type rule for cross-reference.');
+        // expectError(validationResult, 'Cannot use rule fragments in types.');
+    });
+});
+
 describe('Checked Named CrossRefs', () => {
     const input = `
     grammar g

packages/langium/test/grammar/type-system/type-validator.test.ts

@@ -10,6 +10,8 @@ import { DiagnosticSeverity } from 'vscode-languageserver';
 import { AstUtils, EmptyFileSystem, GrammarAST } from 'langium';
 import { createLangiumGrammarServices } from 'langium/grammar';
 import { expectError, expectNoIssues, parseDocument, validationHelper } from 'langium/test';
+import { isCrossReference, isInferredType, isParserRule } from '../../../src/languages/generated/ast.js';
+import type { Assignment, CrossReference, Group, ParserRule } from '../../../src/languages/generated/ast.js';
 
 const grammarServices = createLangiumGrammarServices(EmptyFileSystem).grammar;
 const validate = validationHelper<GrammarAST.Grammar>(grammarServices);
@@ -86,19 +88,37 @@ describe('validate params in types', () => {
 });
 
 describe('validate inferred types', () => {
+    const prog = `
+    A infers B: 'a' name=ID (otherA=[B])?;
+    hidden terminal WS: /\\s+/;
+    terminal ID: /[a-zA-Z_][a-zA-Z0-9_]*/;
+    `.trim();
 
     test('inferred type in cross-reference should not produce an error', async () => {
-        const prog = `
-        A infers B: 'a' name=ID (otherA=[B])?;
-        hidden terminal WS: /\\s+/;
-        terminal ID: /[a-zA-Z_][a-zA-Z0-9_]*/;
-        `.trim();
-
         const validation = await validate(prog);
         expectNoIssues(validation, {
             severity: DiagnosticSeverity.Error
         });
     });
+
+    test('AbstractType for cross-reference includes InferredType', async () => {
+        const validation = await validate(prog);
+        // parser rule with explicitly inferred type
+        const rule: ParserRule = validation.document.parseResult.value.rules.filter(r => isParserRule(r))[0] as ParserRule;
+        expect(rule.inferredType).toBeTruthy();
+        expect(rule.inferredType!.name).toBe('B');
+        // determine the cross-reference
+        const assignment: Assignment = (rule.definition as Group).elements[2] as Assignment;
+        expect(isCrossReference(assignment.terminal)).toBeTruthy();
+        const crossRef: CrossReference = assignment.terminal as CrossReference;
+        const refType = crossRef.type.ref!;
+        // the type of the cross-reference is the inferred type of the parser rule
+        expect(isInferredType(refType)).toBeTruthy();
+        expect(refType.$type).toBe('InferredType');
+        if (isInferredType(refType)) {
+            expect(isParserRule(refType.$container)).toBeTruthy();
+        }
+    });
 });
 
 describe('Work with imported declared types', () => {