Generated type from declared type does not include all of them

[luan-xiaokun]

Hi guys, I'm using the declared types in the grammar definition and find something that somehow confuses me. #693 mentions that there are still some issues regarding the type declaration mechanism, and I want to know if the problem I'm having is one of them, or if there's something I haven't figured out yet. Thanks in advance.

Problems

1. The first problem is that when I declare a union type in the grammar, its generated type does not include all of them. For example, the following declaration and parse rule claim that TupleType UnionType and ListType are contained in Type. But in the generated typescript file, these types are missing, though they are still subtypes of Type according to the isSubtype function.

type Type =
    PrimitiveType | EnumType | StructType | AliasType
    | ListType | TupleType | UnionType;

TypeRule returns Type:
    (PrimitiveType | EnumType | StructTypeRule | AliasType | TupleType)
    ({ListType.base=current} '[' (capacity=Expression)? ']')*
    ({UnionType.types+=current} '|' types+=TypeRule)*;

export type Type = AliasType | EnumType | PrimitiveType | StructType;

2. The second problem is that when (1) the name of the type and the parse rule are the same, and (2) it is crossed referenced in the same file, an error is raised: Use the rule type 'X' instead of the typed rule name 'X' for cross references., which means that langium thinks X refers to the typed parse rule instead of the declared type. I'm not sure if this error will occur when using type inference, but I found that (1) changing the name of the parse rule, or (2) put the type declaration & parse rule and cross reference in different files, can both solve this problem.
   However, there are two strange things:

• The second way sometimes does not help. When I modify the grammar file, or maybe restart the editor, sometimes this error is raised again for the types whose declaration and cross reference are placed in different files (and that's why I'm using TypeRule as the parse rule name).
• I cannot reproduce this behavior right now

3. The third problem is that unimported files can affect irrelevant files. I have a debug grammar file that has some rules with the same names. I never imported the debug file, but when I modify the debug file, the irrelevant files who have same parse rule names will raise error Referenced rule "X" is not imported. (This issue checkGrammarTypeInfer validation ignores declared types in other .langium files #728 seems to be relevant) This issue does not seem to be relevant to declared types, but I still include it in this discussion anyway.

More background

The second and third problems came after I split a single grammar definition file into several, there are circular imports in these files, for example:

• file main: import './A', './B', './interface',
• file A: import './main',
• file B: import './main',
• file interface: no import,

where the interface file only includes interface and type declaration.
#693 also suggests that the inference mechanism should be preferred currently, but I didn't see this advice until after I encountered these problems :( Currently there are about 60 interface declarations and 10 type definition in the interface.langium file.

By the way, I think the title of the question is important because it can help others when searching for similar issues. But this discussion clearly contain several questions, what do you think is the best way to name this discussion?

[msujew]

Hey @luan-xiaokun,

thanks for all the feedback. Yeah, as mentioned in the other discussions, declared types are still in active development. There is a lot going on behind the scenes regarding that topic.

I believe the best way to address this topic by creating GitHub issues with reproducible examples. We can use later use those as test cases when we're getting to fixing them.

[luan-xiaokun]

Sure, I'll try to give minimal reproducible examples in the issues for these problems.