Polymorphism in grammar rules

[theogiraudet]

I'm trying to create a rule that returns a common type of all subrules. When I write my grammar, Langium throws an error:

If I understand the error (and the code throwing this error), the rule infers a union that is transformed to a TypeScript type but I want to return an interface. These two kinds of return are incompatible, throwing this error.
I think this problem really restricts the usefulness of the model design but I don't really know if it's a bug or a intented behavior (due to the typing nature of TypeScript).

Thanks!

[msujew]

Hi @theogiraudet,

It is intended behavior. Basically everytime your grammar rule looks like X: Y | Z | ...; (even when it's only X: Y;) it gets transformed into a type of type X = Y | Z | .... It doesn't really restrict the model, but it's probably non-obvious why:

When performing the union over different types, all common properties across them get pulled to the union type. If both A and B have a value property (and they do, since they inherit from the Value interface), the generated type from ValueRule: ARule | BRule also contains value, since both alternatives contain that type as well. In that sense, the type doesn't lose any information that it shouldn't know in the first place. In that sense, the union type is superior to the interface, because it contains the correct properties and also allows us to perform discriminated union checks, which wouldn't be possible with interface inheritance.

I don't really see a good reason for returning interfaces instead of union types with that in mind. Do you think it restricts the modeling space?

[theogiraudet]

Thanks for your answer! Indead, I am used to the typing system in Java so it's a bit new to me.
The argument I see is about the maintainability. Let's assume a very large model with a type Element and multiple subinterfaces (several dozen). I want to make it evolve by adding a new property to all Element subinterfaces. If Element is an interface, I juste have to add the new property to it, but if is a type, I have to modify each subinterface to add the property.

By trying to think about it in a more TypeScript way, I have just found this:

entry ValueRule returns Value:
    BRule;

BRule returns B:
    value?='b';

type Value = A | B;

interface IValue {
    value: boolean
}

interface A extends IValue {}
interface B extends IValue {}

Perhaps is the way you recommand? If yes, sorry, this is more a discussion about TypeScript than about Langium ^^'

[msujew]

Right. I probably should have put it more explicitly: You're able to construct your interfaces completely independent of Langium's parser rules. An interface such as your IValue is exactly the right way to go about sharing properties across different types (at least since Langium 0.4, before that we had a few bugs related to that).

[theogiraudet]

Okay, with your explication and some tests from on my side, I understand better. Thanks for your help!