Creating separate objects for multiple identifiers

[MarianBaba]

Hello everyone,

I am working on a DSL for defining communication protocols. I have encountered a problem while defining the grammar of this language.

One of the entities in this DSL is called "principal", and, as is the case with traditional programming languages, I would like to be able to declare multiple "principals" in a single statement, like this:

principal A, B, C

(similar to "int i, j, k" in Java or other languages)

However, I would like the parsing process to create three separate Principal objects, rather than a single Principal object with three identifiers stored in an array. Now, I have written the grammar definition to allow writing this type of statement in the following way:

Principal:
    'principal' name+=ID (',' name+=ID)*;

However, this method of defining the entity does not allow me to do cross-referencing when I use the name of a principal in another part of a file written in my DSL. The underlying problem is that the parser, when encountering a statement like this, creates a Principal object with a "name" field of type "Array<string>."

What I want is to write statements where I can declare multiple principals at once, but I want the parser to create separate objects for each principal identifier. In other words, if I write:

principal A, B, C

I would like three "Principal" objects to be created, each with a single identifier (not one object with three identifiers).

To be even more clear, the TypeScript interface to achieve this should look like this:

export interface Principal extends AstNode {
    name: string;
}

Currently, the interface generated by Langium for this entity looks like this:

export interface Principal extends AstNode {
    name: Array<string>;
}

How can I achieve what I have described? Is there a way to do it? If not, do the developers have plans to add support for this type of definition? Thank you in advance for any answers or any form of help!

[dhuebner]

@MarianBaba
You need to create a separate ParserRule for principal so that you get new instances.
Would that fit?

[MarianBaba]

This looks pretty much exactly what I want, but for some reason Langium still can't resolve cross-references the way I want it to. I added another rule "Message" to your example to test this:

grammar HelloWorld

entry Model:
   elements+=Element*;

Element: Principals | Message;

Principals:
    'principal' elements+=Principal (',' elements+=Principal)*;

Principal:
    name = ID;

Message: 
    sender=[Principal:ID] 'sends' 'something';

hidden terminal WS: /\s+/;
terminal ID: /[_a-zA-Z][\w_]*/;
hidden terminal ML_COMMENT: /\/\*[\s\S]*?\*\//;
hidden terminal SL_COMMENT: /\/\/[^\n\r]*/;

And then I wrote:

principal A, B, C
A sends something

But it gives me a linking error "Could not resolve reference to Principal named A". Maybe I'm missing something, I clearly misunderstood how Langium resolves cross-references. Do you have any advice regarding this?

[msujew]

A, B and C live in the scope of the Principals object and the default scope provider doesn't know about them outside of this object. You need to make these references available through the local scope mechanism. We have some documentation on that on our website. Look for the fully qualified name scoping guide.

[MarianBaba]

So, I followed what is explained in the fully qualified name scoping guide and created a file "scope-computation.ts", where I wrote the following code:

export class HelloWorldScopeComputation extends DefaultScopeComputation {
    constructor(services: LangiumServices) {
        super(services)
    }

    override async computeExports(document: LangiumDocument): Promise<AstNodeDescription[]> {
        const exportedDescriptions: AstNodeDescription[] = []
        for (const childNode in streamAllContents(document.parseResult.value)) {
            if (isPrincipal(childNode)) {
               // exporting every principal name
                exportedDescriptions.push(this.descriptions.createDescription(childNode, childNode.name))
            }
        }
        return exportedDescriptions
    }

    override async computeLocalScopes(document: LangiumDocument): Promise<PrecomputedScopes> {
        const model = document.parseResult.value
        const scopes = new MultiMap<AstNode, AstNodeDescription>()
        streamAllContents(model).filter(isPrincipal).forEach(principal => {
            scopes.add(model, this.descriptions.createDescription(principal, principal.name, document))
        })
        return scopes
    }
    
}

export const HelloWorldModule: Module<HelloWorldServices, PartialLangiumServices & HelloWorldAddedServices> = {
    validation: {
        HelloWorldValidator: HelloWorldValidator
    },
    references: {
        ScopeComputation: (services) => new HelloWorldScopeComputation(services)
    }
}

But when I write

principal A
A sends something

the error "Could not resolve reference to Principal named A" is still there. Am I doing something wrong?

[msujew]

I haven't tested it, but it looks correct on first glance. Do you have a reproducable repo so I could test it and see where the issue is?