LangiumDocuments and WorkspaceManager

[ballcoach12]

Based on the changes in #377, my understanding is that, starting with 0.3.0, any document that is included in a workspace is automatically indexed by the WorkspaceManager. I want to make sure that I understand how this is intended to be used, so please comment at your leisure on whether I am using it as designed.

I intend to configure my language project to have a second grammar/language that imports the first:

langium-config.json

{
    "projectName": "Xeta",
    "languages": [{
        "id": "xeta",
        "grammar": "src/language-server/xeta.langium",
        "fileExtensions": [".xeta"],
        "textMate": {
            "out": "syntaxes/xeta.tmLanguage.json"
        }
    },
    {    "id": "xeta-behaviors",
         "grammar":  "src/language-server/xeta-behaviors.langium",
         "fileExtensions":  [".behaviors"],
         "textMate": {
             "out": "syntaxes/xeta-behaviors.tmLanguage.json"
         }
    }
],
    "out": "src/language-server/generated"
}

Next, I have configured my language server project to export a resources/ folder that includes the file that serves as the source for items in the global scope:

/resources/global.behaviors

package xeta.global

<Behavior id="SetStyleAttributeBehavior">
	<Parameters>
		<Parameter name="bob" value="steve"  />
	</Parameters>
</Behavior>

Next, I have created a task in package.json to copy the /resources/global.behaviors file to the output directory.

Lastly, I am relying on the behavior of the default WorkspaceManager to index this file so that it is included in the LangiumDocument collection for the workspace.

If this sounds OK so far, here is my question:

How do I add the parsed contents of the global.behaviors file to the global scope? Do I need to add a custom ScopeProvider that does this, or is there already a mechanism in place in Langium to be able to use an external resource like this to resolve cross references? In other words, are the parsed contents of the external resource document a pre-computed scope?

[spoenemann]

You'll need to create a subclass of DefaultWorkspaceManager and override loadAdditionalDocuments to include those that should be implicitly available. Then their content should be included in the index so cross-references can be resolved.

[ballcoach12]

I ended up with a slightly different solution.

Instead of two grammars, I combined them into one and adjusted my entry rule to look like this:

entry TemplateLibraryModel:
     (packages+=BehaviorPackage)*
     (libraries+=TemplateLibrary)*
 ;

I modified the langium-config.json file to specify a single grammar with two different file extensions:

{
    "projectName": "Xeta",
    "languages": [
        {
        "id": "xeta",
        "grammar": "src/language-server/xeta.langium",
        "fileExtensions": [".xeta", ".behaviors"],
        "textMate": {
            "out": "syntaxes/xeta.tmLanguage.json"
        }
    }
    
],
    "out": "src/language-server/generated"
}

I then wrote a custom ScopeProvider that loads the global scope with elements from the .behaviors file that ships with the language server:

import { AstNodeDescription, AstNodeDescriptionProvider, DefaultScopeProvider, EMPTY_SCOPE, getDocument, LangiumDocument, LangiumServices, Scope, stream, Stream, StreamScope } from 'langium';
import { URI } from 'vscode-uri';
import { TemplateLibraryModel } from './generated/ast';
export class XetaScopeProvider extends DefaultScopeProvider {

    services: LangiumServices;
    descriptionProvider: AstNodeDescriptionProvider;
    behaviorScope: Scope;
    
    constructor(services: LangiumServices){
        super(services);
        this.services = services;
        this.descriptionProvider = services.index.AstNodeDescriptionProvider;
    }

    private buildBehaviorScope(doc: LangiumDocument) : Stream<AstNodeDescription> {
        var model = doc.parseResult.value as TemplateLibraryModel;
        
       let descriptions = stream(model.packages.map((pkg =>  pkg.behaviors)).flat().map(beh =>         
            this.descriptionProvider.createDescription(beh, beh.name, getDocument(beh))));
       
        return descriptions;
    }
    protected getGlobalScope(referenceType: string): Scope {
        if(referenceType === "Behavior"){
            if(!this.behaviorScope){
                // read in the external behaviors if the reference type matches
                var  uri = URI.file(__dirname + '/resources/global.behaviors');
                var document = this.services.shared.workspace.LangiumDocuments.getOrCreateDocument(uri);
                if(document){
                    var desc = this.buildBehaviorScope(document);
                    this.behaviorScope = new StreamScope(desc);               
                }
                else {
                    this.behaviorScope = EMPTY_SCOPE;
                }
            }
           
           return this.behaviorScope;
        }
        else{
            return EMPTY_SCOPE;
        }
    }
}

This seems to do the trick.

I think I generally understand the approach that you recommend as well, so thank you for the quick reply!