Scoping of referenced variables.

[nasabenz]

I am new to language engineering and giving Langium a trial. I have what I hope is a simple question:

A simple start to a language

I ultimately want to create DSL for for a space flight software framework. At the top level it uses a publish/subscribe mechanism to exchange messages between software applications.

I modified the HelloWorld example, to this

grammar CoreFlightSystem

// Define the syntax of the language
entry Model: (apps+=App)* ;

App:
    'app' name=ID '{'
        (publish+=Publish | subscribe+=Subscribe | table+=Table)*
    '}';

Publish: 'pub:' name=ID ;

Subscribe: 'sub:' subscribe=[Publish:ID];

Table: 'table:' name=ID;

// Define the keywords in the language
terminal ID: (/[a-z]/ | /[A-Z]/ | '_') (/[a-z]/ | /[A-Z]/ | '_' | /[0-9]/)*;

hidden terminal WS:             /\s+/;
hidden terminal ML_COMMENT:     /\/\*[\s\S]*?\*\//;
hidden terminal SL_COMMENT:     /\/\/[^\n\r]*/;

The DSL allows the user to create an app. Define the messages the app publishes and the messages the app subscribes to. The messages subscribed to must be message another app publishes. This is where I don't know how to implement scoping.

Putting this into the playground:

The DSL gives an error when trying to reference a published message that is outside of the scope of the app. There is no error when referencing a message within the scope of the app.

The question how do I implement something like below

app myApp
    pub: my_msg
    sub: **myOtherApp.other_msg**
    table: myTable

app myOtherApp
    pub: other_msg

[montymxb]

Hey @nasabenz . Yep you're running into the default scoping, which works in most cases, but sounds like you're looking for something that works with qualified names instead.

We actually have an example for such a project, the Domain Model example, that utilizes qualified names to correctly resolve cross-references from other parts of your program. Specifically here's an example program that uses qualified names in the example domain model language.

In order to be able to support using qualified names to resolve scoping correctly, you're going to want to look into that example and checkout the grammar (as you'll need to support QNs there), as well as implementing the associated services to support QN computation & resolution. For more details, you can read up on our guide for implementing qualified name scoping as well 😉 .

[nasabenz]

Thanks this is the type of example and documentation I was looking for.