Type Usage Consistency (2)

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

@@ -21,6 +21,7 @@ import * as ast from './generated/ast';
 import { isParserRule, isRuleCall } from './generated/ast';
 import { findKeywordNode, findNameAssignment, getEntryRule, getTypeName, isDataTypeRule, isOptional, resolveImport, resolveTransitiveImports, terminalRegex } from './grammar-util';
 import type { LangiumGrammarServices } from './langium-grammar-module';
+import { collectInferredTypes } from './type-system/inferred-types';
 import { applyErrorToAssignment, collectAllInterfaces, InterfaceInfo, validateTypesConsistency } from './type-system/type-validator';
 
 export class LangiumGrammarValidationRegistry extends ValidationRegistry {
@@ -415,10 +416,22 @@ export class LangiumGrammarValidator {
                 accept('error', 'Rules are not allowed to return union types.', { node: rule, property: 'returnType' });
             }
         }
+
         for (const interfaceType of grammar.interfaces) {
             interfaceType.superTypes.forEach((superType, i) => {
                 if (superType.ref && ast.isType(superType.ref)) {
                     accept('error', 'Interfaces cannot extend union types.', { node: interfaceType, property: 'superTypes', index: i });
+                } else if(superType.ref && ast.isParserRule(superType.ref)) {
+                    // collect just the beginning of whatever inferred types this standalone rule produces
+                    // looking to exclude anything that would be a union down the line
+                    const inferred = collectInferredTypes([superType.ref as ast.ParserRule], []);
+                    if(inferred.unions.length > 0) {
+                        // inferred union type also cannot be extended
+                        accept('error', `An interface cannot extend a union type, which was inferred from parser rule ${superType.ref.name}.`, { node: interfaceType, property: 'superTypes', index: i });
+                    } else {
+                        // otherwise we'll allow it, but issue a warning against basing declared off of inferred types
+                        accept('warning', 'Extending an interface by a parser rule gives an ambiguous type, instead of the expected declared type.', { node: interfaceType, property: 'superTypes', index: i });
+                    }
                 }
             });
         }

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

@@ -6,7 +6,7 @@
 
 import { createLangiumGrammarServices } from '../../src';
 import { Assignment, Grammar, ParserRule } from '../../src/grammar/generated/ast';
-import { expectError, validationHelper } from '../../src/test';
+import { expectError, expectWarning, validationHelper } from '../../src/test';
 
 const services = createLangiumGrammarServices();
 const validate = validationHelper<Grammar>(services.grammar);
@@ -30,4 +30,35 @@ describe('Langium grammar validation', () => {
             property: {name: 'terminal'}
         });
     });
+
+    test('Interfaces should only be able to extend inferred interfaces', async () => {
+        const validationResult = await validate(`
+        grammar G
+
+        entry SA: S1 | S2;
+        SB: S1;
+
+        S1: 's1' s1=ID;
+        S2: 's2' s2=ID;
+
+        interface DA extends SA {}
+        interface D2 extends S2 {}
+        interface DB extends SB {}
+
+        hidden terminal WS: /\\s+/;
+        terminal ID: /[a-zA-Z_][a-zA-Z0-9_]*/;
+        `);
+        expectError(validationResult, /An interface cannot extend a union type, which was inferred from parser rule SA./, {
+            node: validationResult.document.parseResult.value.interfaces[0],
+            property: {name: 'superTypes'}
+        });
+        expectWarning(validationResult, /Extending an interface by a parser rule gives an ambiguous type, instead of the expected declared type./, {
+            node: validationResult.document.parseResult.value.interfaces[1],
+            property: {name: 'superTypes'}
+        });
+        expectError(validationResult, /An interface cannot extend a union type, which was inferred from parser rule SB./, {
+            node: validationResult.document.parseResult.value.interfaces[2],
+            property: {name: 'superTypes'}
+        });
+    });
 });