Default Value for Language Feature

[ballcoach12]

I need a way to set default values for language features that are optional in a grammar. In Xtext, you could use a PostProcessor to do this. Is there a way to do this in Langium? I could imagine that it might be accomplished in the grammar definition itself, maybe like this:

Greeting:
'Hello, " (name=STRING {'Charlie'})?;

[msujew]

Hi @ballcoach12,

Interesting proposal, currently there's no built-in way to accomplish this.

However, before processing your AST content you could simply run:

streamAllContents(rootElement).forEach(e => {
  if (isGreeting(e.node) && e.node.name === undefined) {
    e.node.name = 'Charlie'; 
  }
})

This should accomplish the same thing for now.

[ballcoach12]

@spoenemann, I am finally getting back to working on this. Here is what I came up with, which I think aligns with what you were recommending:

export class FeederDocumentFactory extends DefaultLangiumDocumentFactory {

    constructor(services: LangiumSharedServices) {
        super(services);
    }

    override fromTextDocument<T extends AstNode = AstNode>(textDocument: TextDocument): LangiumDocument<T> {
        var returnValue = super.fromTextDocument<T>(textDocument);
        let rootElement = returnValue.parseResult.value;
        if (isFeeder(rootElement)) {
            if(rootElement.uniqueId === undefined){
                rootElement.uniqueId = generateUniqueId();
            }
            if (rootElement.eventDetSecs === undefined) {
                rootElement.eventDetSecs = 3;
            }
            if (rootElement.isLossSourceDetEna === undefined) {
                rootElement.isLossSourceDetEna = false;
            }
            if (rootElement.isMiscoordDetEna === undefined) {
                rootElement.isMiscoordDetEna = false;
            }
            if (rootElement.isOpenPhaseDetEnab === undefined) {
                rootElement.isOpenPhaseDetEnab = false;
            }
            if (rootElement.nomVolt === undefined) {
                rootElement.nomVolt = 12470;
            }
            if (rootElement.openPhaseDetSecs === undefined) {
                rootElement.openPhaseDetSecs = 3;
            }
            if (rootElement.rtrnToNormalMode === undefined) {
                rootElement.rtrnToNormalMode = "Disabled";
            }
            if (rootElement.shouldIsoOpenPhase === undefined) {
                rootElement.shouldIsoOpenPhase = false;
            }
           
        }
        streamAllContents(rootElement).forEach(e => {
            if (isEdgeStmt(e)) {
                if (e.uniqueId === undefined) {
                    e.uniqueId = generateUniqueId();
                }
            }
            if (isEdgeRhs(e)) {
                if (e.uniqueId === undefined) {
                    e.uniqueId = generateUniqueId();
                }
                if (e.loadCapPercent === undefined) {
                    e.loadCapPercent = 100;
                }
                if (e.tempCapPercent === undefined) {
                    e.tempCapPercent = 100;
                }
            }
            if (isDevice(e)) {
                if (e.uniqueId === undefined) {
                    e.uniqueId = generateUniqueId();
                }
                if (e.isBrkr || e.isRecloser || e.isSwitch) {
                    if (e.loadCap === undefined) {
                        e.loadCap = 12134567;
                    }
                    if (e.tempCap === undefined) {
                        e.tempCap = 100;
                    }
                    if (e.normalStatus === undefined) {
                        e.normalStatus = "Closed";
                    }
                    if (e.leftPTPosition === null) {
                        e.leftPTPosition = 'None';
                    }
                    if (e.rightPTPosition === null) {
                        e.rightPTPosition = 'None';
                    }
                }
                if (e.isNeighboringFeeder) {
                    if (e.loadCap === undefined) {
                        e.loadCap = 100;
                    }
                    if (e.tempCap === undefined) {
                        e.tempCap = 100;
                    }
                }
            }
        })
        return returnValue;
    }
}

and here is how I inject it:

export const FlisrFeederDslModule: Module<FlisrFeederDslServices, PartialLangiumServices & FlisrFeederDslAddedServices> = {
    validation: {
        ValidationRegistry: (services) => new FlisrFeederDslValidationRegistry(services),
        FlisrFeederDslValidator: () => new FlisrFeederDslValidator()
    }
    ,
    shared: {
        workspace: {
            LangiumDocumentFactory: (services) => new FeederDocumentFactory(services.shared)
        }
    }
};

The problem is that in the create() function in DefaultLangiumDocumentFactory cannot find a "serviceRegistry". Maybe I'm not injecting things correctly?

I have a unit test that calls the following function in my module:

export function createFlisrFeederDslServices(context?: DefaultSharedModuleContext): {
    shared: LangiumSharedServices,
    FlisrFeederDsl: FlisrFeederDslServices
} {
    const shared = inject(
        createDefaultSharedModule(context),
        FlisrFeederDslGeneratedSharedModule
    );
    const FlisrFeederDsl = inject(
        createDefaultModule({ shared }),
        FlisrFeederDslGeneratedModule,
        FlisrFeederDslModule
    );
    shared.ServiceRegistry.register(FlisrFeederDsl);

    
    return { shared, FlisrFeederDsl };
}

Not sure what I am doing wrong in this case.

[spoenemann]

The shared services are created in a separate call to inject. You need to create a new module:

export const FlisrFeederDslSharedModule: Module<LangiumSharedServices, PartialLangiumSharedServices> = {
    workspace: {
        LangiumDocumentFactory: (services) => new FeederDocumentFactory(services)
    }
};

and add this to the respective inject call.

[ballcoach12]

Perfect! Thank you! That was the missing piece!

[Yokozuna59]

Hi there, I came across the same question, but the current approach would still make the attribute as optional. So, from a design perspective, would you recommend extending the interface to make the attribute as defined? Using result.value?.attribute isn't the best choice.

[msujew]

Rethinking this, it might make sense to add default values to declared interfaces. I'm imagining something like this - which should also keep the performance overhead at a minimum:

interface Item {
  value: string;
  version: string = "2.0.0"
}

I've created an issue for this over at #1154.