What is the recommended way to access the AST?

[ballcoach12]

I need to do a model-to-model transformation from my language's AST to a foreign model (FWIW, the foreign model has no DSL; its implementation is produced from a protobuf file, so I'm just manually translating my AST objects into instances of the foreign model).

In my transformation function, I need to obtain the root node of my AST, assuming that there are no validation errors that resulted from the last parse/validate run, and use that node as the basis of transformation.

My question is: should I get the current document from the editor, re-initiate parsing, and then obtain the root node from the parseResult, or is getting it from the index service a better way to go? If there are code examples for what's recommended, that would be much appreciated!

[msujew]

@ballcoach12 The easies way would probably to simply ask the LangiumDocuments service. Each LangiumDocument contains a ParseResult, where the ParseResult#value property is your AST root node. No reparsing necessary :)

[ballcoach12]

My assumption was that LangiumDocuments handles documents that are currently open in the editors behind the scenes; so I am just getting an instance of services like this:

const services = createFlisrFeederDslServices();
...

let docs = services.documents.LangiumDocuments.all.toArray();

Is there additional work that I need to do in order to set up the workspace?

[msujew]

Might be, that depends on what is happening in the ... bit. Calling createFlisrFeederDslServices() will create a completely fresh instance of all your services (including the LangiumDocuments service, which is akin to Xtext's ResourceSet), so your ... code will need to call LangiumDocuments#getOrCreateDocument in one way or another.

Are we talking about an LSP or CLI context here? When running in the language server, you can simply hook into an existing service, like the document builder or something, and access the LangiumDocuments there. The language server part of Langium should take care of initializing the workspace and keeping track of changed files. For CLI usage, you can take a look at the examples:

https://github.com/langium/langium/blob/665d7ced4f7e6ff3323fc9e02bbbe56c74ccf6f0/examples/domainmodel/src/cli/cli-util.ts#L25-L26

[ballcoach12]

Thanks for the reply, @msujew. We are in the language server context. The '...' part is the body of my extension. Overall, I am attempting to handle a command that, when executed, will transform the AST into a foreign model for transmission to another API via gRPC.

I think where I am struggling is knowing how to tap into the existing service, like the document builder. I have been treating createFlisrFeederDslServices() as if it's a Singleton, which it isn't. Here is the code for my extension:

let client: LanguageClient;
let outputChannel: vscode.OutputChannel;
const services = createFlisrFeederDslServices();

// This function is called when the extension is activated.
export function activate(context: vscode.ExtensionContext): void {
    client = startLanguageClient(context);

    // register the non-user facing commands
    // (https://code.visualstudio.com/api/extension-guides/command#creating-a-user-facing-command)
    
    // HACK: for now, so that we can test, we will make this a user-facing command by placing it in 
    // the package.json so that a user can invoke it from the command window. Utlimately, though,
    // we will put it in here and remove it from the package.json
    registerCommands(context);
}

// This function is called when the extension is deactivated.
export function deactivate(): Thenable<void> | undefined {
    if (client) {
        return client.stop();
    }
    return undefined;
}

function handleDeploy(){
   
   
   let docs = services.documents.LangiumDocuments.all.toArray();
   let feeder = docs[0].parseResult.value;
   console.log(feeder.name);
  //TODO: make the M2M transformation here...
    
}

function registerCommands(context: vscode.ExtensionContext): void {
    const command = 'feeder.deploy';
    context.subscriptions.push(vscode.commands.registerCommand(command, handleDeploy));
    outputChannel.appendLine("Added feeder.deploy command.");
}
function startLanguageClient(context: vscode.ExtensionContext): LanguageClient {
    outputChannel  = vscode.window.createOutputChannel("Language Server");    

    const serverModule = context.asAbsolutePath(path.join('out', 'language-server', 'main'));
    // The debug options for the server
    // --inspect=6009: runs the server in Node's Inspector mode so VS Code can attach to the server for debugging.
    // By setting `process.env.DEBUG_BREAK` to a truthy value, the language server will wait until a debugger is attached.
    const debugOptions = { execArgv: ['--nolazy', `--inspect${process.env.DEBUG_BREAK ? '-brk' : ''}=${process.env.DEBUG_SOCKET || '6009'}`] };

    // If the extension is launched in debug mode then the debug server options are used
    // Otherwise the run options are used
    const serverOptions: ServerOptions = {
        run: { module: serverModule, transport: TransportKind.ipc },
        debug: { module: serverModule, transport: TransportKind.ipc, options: debugOptions }
    };

    const fileSystemWatcher = vscode.workspace.createFileSystemWatcher('**/*.feeder');
    context.subscriptions.push(fileSystemWatcher);

    // Options to control the language client
    const clientOptions: LanguageClientOptions = {
        documentSelector: [{ scheme: 'file', language: 'flisr-feeder-dsl' }],
        synchronize: {
            // Notify the server about file changes to files contained in the workspace
            fileEvents: fileSystemWatcher
        }
    };

    // Create the language client and start the client.
    const client = new LanguageClient(
        'flisr-feeder-dsl',
        'FLISR Feeder DSL',
        serverOptions,
        clientOptions
    );

    // Start the client. This will also launch the server
    outputChannel.appendLine("starting language client")
    client.start();
    return client;
}

The handleDeploy() function is where I am struggling. My expectation is that the document service provides access to all the parsed documents from the open editors in the workspace; but I'm just not sure how to access the correct instance.

[msujew]

Ah, I see. Thanks for providing more context on that. I assume there's some confusion going on about how the language server operates in the vscode extension context:

So first off, createFlisrFeederDslServices() creates a new instance of your services, including a new LangiumDocuments service. However, we usually treat it like a singleton in the language server context, since only a single service container instance is created for the whole language server. The issue here is that the language server runs in its own dedicated process. Consequently, you don't have access to the services in your vscode extension. This is the reason LangiumDocuments#all returns empty.

Generally, you should avoid trying to run language server related code in your vscode extension code, since this might impact the extension host in general (all vscode extensions run in a single-threaded node.js process). Instead, you should use the command LSP endpoint to call into the language server when invoking a vscode command. The command implementation (in the language server) can then return a model in json format to the client (vscode). I would perform the m2m transformation on the language server side, since Langiums cross references can no longer be resolved on the client side.

[ballcoach12]

OK. Thanks. That's really helpful information. I had read, but forgotten, that the language server runs in its own process. I'll investigate using the command LSP endpoint instead and doing the m2m transformation in my language server.