Improve workspace manager startup behavior (#1388)

Author: msujew

packages/langium/src/lsp/document-update-handler.ts

@@ -11,6 +11,7 @@ import type { DocumentBuilder } from '../workspace/document-builder.js';
 import type { TextDocument } from '../workspace/documents.js';
 import type { WorkspaceLock } from '../workspace/workspace-lock.js';
 import type { LangiumSharedServices } from './lsp-services.js';
+import type { WorkspaceManager } from '../workspace/workspace-manager.js';
 
 /**
  * Shared service for handling text document changes and watching relevant files.
@@ -31,10 +32,12 @@ export interface DocumentUpdateHandler {
 
 export class DefaultDocumentUpdateHandler implements DocumentUpdateHandler {
 
+    protected readonly workspaceManager: WorkspaceManager;
     protected readonly documentBuilder: DocumentBuilder;
     protected readonly workspaceLock: WorkspaceLock;
 
     constructor(services: LangiumSharedServices) {
+        this.workspaceManager = services.workspace.WorkspaceManager;
         this.documentBuilder = services.workspace.DocumentBuilder;
         this.workspaceLock = services.workspace.WorkspaceLock;
 
@@ -70,7 +73,14 @@ export class DefaultDocumentUpdateHandler implements DocumentUpdateHandler {
     }
 
     protected fireDocumentUpdate(changed: URI[], deleted: URI[]): void {
-        this.workspaceLock.write(token => this.documentBuilder.update(changed, deleted, token));
+        // Only fire the document update when the workspace manager is ready
+        // Otherwise, we might miss the initial indexing of the workspace
+        this.workspaceManager.ready.then(() => {
+            this.workspaceLock.write(token => this.documentBuilder.update(changed, deleted, token));
+        }).catch(err => {
+            // This should never happen, but if it does, we want to know about it
+            console.error('Workspace initialization failed. Could not perform document update.', err);
+        });
     }
 
     didChangeContent(change: TextDocumentChangeEvent<TextDocument>): void {

packages/langium/src/parser/async-parser.ts

@@ -125,7 +125,7 @@ export abstract class AbstractThreadedAsyncParser implements AsyncParser {
             if (index >= 0) {
                 this.queue.splice(index, 1);
             }
-            deferred.reject('OperationCancelled');
+            deferred.reject(OperationCancelled);
         });
         this.queue.push(deferred);
         return deferred.promise;

packages/langium/src/workspace/configuration.ts

@@ -7,11 +7,17 @@
 import type { ConfigurationItem, DidChangeConfigurationParams, DidChangeConfigurationRegistrationOptions, InitializeParams, InitializedParams } from 'vscode-languageserver-protocol';
 import type { ServiceRegistry } from '../service-registry.js';
 import type { LangiumSharedCoreServices } from '../services.js';
+import { Deferred } from '../utils/promise-utils.js';
 
 /* eslint-disable @typescript-eslint/no-explicit-any */
 
 export interface ConfigurationProvider {
 
+    /**
+     * A promise that resolves when the configuration provider is ready to be used.
+     */
+    readonly ready: Promise<void>;
+
     /**
      * When used in a language server context, this method is called when the server receives
      * the `initialize` request.
@@ -52,14 +58,18 @@ export interface ConfigurationInitializedParams extends InitializedParams {
 export class DefaultConfigurationProvider implements ConfigurationProvider {
 
     protected readonly serviceRegistry: ServiceRegistry;
+    protected readonly _ready = new Deferred<void>();
     protected settings: Record<string, Record<string, any>> = {};
     protected workspaceConfig = false;
-    protected fetchConfiguration: ((configurations: ConfigurationItem[]) => Promise<any>) | undefined;
 
     constructor(services: LangiumSharedCoreServices) {
         this.serviceRegistry = services.ServiceRegistry;
     }
 
+    get ready(): Promise<void> {
+        return this._ready.promise;
+    }
+
     initialize(params: InitializeParams): void {
         this.workspaceConfig = params.capabilities.workspace?.configuration ?? false;
     }
@@ -77,35 +87,22 @@ export class DefaultConfigurationProvider implements ConfigurationProvider {
                 });
             }
 
-            // params.fetchConfiguration(...) is a function to be provided by the calling language server for the sake of
-            //  decoupling this implementation from the concrete LSP implementations, specifically the LSP Connection
-            this.fetchConfiguration = params.fetchConfiguration;
-
-            // awaiting the fetch of the initial configuration data must not happen here, because it would block the
-            //  initialization of the language server, and may lead to out-of-order processing of subsequent messages from the language client;
-            // fetching the initial configuration in a non-blocking manner might cause a read-before-write problem
-            //  in case the workspace initialization relies on that configuration data (which is the case for the grammar language server);
-            // consequently, we fetch the initial configuration data on blocking manner on-demand, when the first configuration value is read,
-            //  see below in #getConfiguration(...);
-        }
-    }
+            if (params.fetchConfiguration) {
+                // params.fetchConfiguration(...) is a function to be provided by the calling language server for the sake of
+                //  decoupling this implementation from the concrete LSP implementations, specifically the LSP Connection
+                const configToUpdate = this.serviceRegistry.all.map(lang => <ConfigurationItem>{
+                    // Fetch the configuration changes for all languages
+                    section: this.toSectionName(lang.LanguageMetaData.languageId)
+                });
 
-    protected async initializeConfiguration(): Promise<void> {
-        if (this.fetchConfiguration) {
-            const configToUpdate = this.serviceRegistry.all.map(lang => <ConfigurationItem>{
-                // Fetch the configuration changes for all languages
-                section: this.toSectionName(lang.LanguageMetaData.languageId)
-            });
-
-            // get workspace configurations (default scope URI)
-            const configs = await this.fetchConfiguration(configToUpdate);
-            configToUpdate.forEach((conf, idx) => {
-                this.updateSectionConfiguration(conf.section!, configs[idx]);
-            });
-
-            // reset the 'fetchConfiguration' to 'undefined' again in order to prevent further 'fetch' attempts
-            this.fetchConfiguration = undefined;
+                // get workspace configurations (default scope URI)
+                const configs = await params.fetchConfiguration(configToUpdate);
+                configToUpdate.forEach((conf, idx) => {
+                    this.updateSectionConfiguration(conf.section!, configs[idx]);
+                });
+            }
         }
+        this._ready.resolve();
     }
 
     /**
@@ -134,7 +131,7 @@ export class DefaultConfigurationProvider implements ConfigurationProvider {
     * @param configuration Configuration name
     */
     async getConfiguration(language: string, configuration: string): Promise<any> {
-        await this.initializeConfiguration();
+        await this.ready;
 
         const sectionName = this.toSectionName(language);
         if (this.settings[sectionName]) {

packages/langium/src/workspace/document-builder.ts

@@ -254,9 +254,9 @@ export class DefaultDocumentBuilder implements DocumentBuilder {
     protected async buildDocuments(documents: LangiumDocument[], options: BuildOptions, cancelToken: CancellationToken): Promise<void> {
         this.prepareBuild(documents, options);
         // 0. Parse content
-        await this.runCancelable(documents, DocumentState.Parsed, cancelToken, doc => {
-            this.langiumDocumentFactory.update(doc, cancelToken);
-        });
+        await this.runCancelable(documents, DocumentState.Parsed, cancelToken, doc =>
+            this.langiumDocumentFactory.update(doc, cancelToken)
+        );
         // 1. Index content
         await this.runCancelable(documents, DocumentState.IndexedContent, cancelToken, doc =>
             this.indexManager.updateContent(doc, cancelToken)
@@ -308,7 +308,7 @@ export class DefaultDocumentBuilder implements DocumentBuilder {
     }
 
     protected async runCancelable(documents: LangiumDocument[], targetState: DocumentState, cancelToken: CancellationToken,
-        callback: (document: LangiumDocument) => MaybePromise<void>): Promise<void> {
+        callback: (document: LangiumDocument) => MaybePromise<unknown>): Promise<void> {
         const filtered = documents.filter(e => e.state < targetState);
         for (const document of filtered) {
             await interruptAndCheck(cancelToken);

packages/langium/src/workspace/workspace-manager.ts

@@ -9,7 +9,7 @@ import type { WorkspaceFolder } from 'vscode-languageserver-types';
 import type { ServiceRegistry } from '../service-registry.js';
 import type { LangiumSharedCoreServices } from '../services.js';
 import { CancellationToken } from '../utils/cancellation.js';
-import { interruptAndCheck } from '../utils/promise-utils.js';
+import { Deferred, interruptAndCheck } from '../utils/promise-utils.js';
 import { URI, UriUtils } from '../utils/uri-utils.js';
 import type { BuildOptions, DocumentBuilder } from './document-builder.js';
 import type { LangiumDocument, LangiumDocuments } from './documents.js';
@@ -29,6 +29,12 @@ export interface WorkspaceManager {
     /** The options used for the initial workspace build. */
     initialBuildOptions: BuildOptions | undefined;
 
+    /**
+     * A promise that resolves when the workspace manager is ready to be used.
+     * Use this to ensure that the workspace manager has finished its initialization.
+     */
+    readonly ready: Promise<void>;
+
     /**
      * When used in a language server context, this method is called when the server receives
      * the `initialize` request.
@@ -61,6 +67,7 @@ export class DefaultWorkspaceManager implements WorkspaceManager {
     protected readonly documentBuilder: DocumentBuilder;
     protected readonly fileSystemProvider: FileSystemProvider;
     protected readonly mutex: WorkspaceLock;
+    protected readonly _ready = new Deferred<void>();
     protected folders?: WorkspaceFolder[];
 
     constructor(services: LangiumSharedCoreServices) {
@@ -71,6 +78,10 @@ export class DefaultWorkspaceManager implements WorkspaceManager {
         this.mutex = services.workspace.WorkspaceLock;
     }
 
+    get ready(): Promise<void> {
+        return this._ready.promise;
+    }
+
     initialize(params: InitializeParams): void {
         this.folders = params.workspaceFolders ?? undefined;
     }
@@ -82,6 +93,18 @@ export class DefaultWorkspaceManager implements WorkspaceManager {
     }
 
     async initializeWorkspace(folders: WorkspaceFolder[], cancelToken = CancellationToken.None): Promise<void> {
+        const documents = await this.performStartup(folders);
+        // Only after creating all documents do we check whether we need to cancel the initialization
+        // The document builder will later pick up on all unprocessed documents
+        await interruptAndCheck(cancelToken);
+        await this.documentBuilder.build(documents, this.initialBuildOptions, cancelToken);
+    }
+
+    /**
+     * Performs the uninterruptable startup sequence of the workspace manager.
+     * This methods loads all documents in the workspace and other documents and returns them.
+     */
+    protected async performStartup(folders: WorkspaceFolder[]): Promise<LangiumDocument[]> {
         const fileExtensions = this.serviceRegistry.all.flatMap(e => e.LanguageMetaData.fileExtensions);
         const documents: LangiumDocument[] = [];
         const collector = (document: LangiumDocument) => {
@@ -98,10 +121,8 @@ export class DefaultWorkspaceManager implements WorkspaceManager {
             folders.map(wf => [wf, this.getRootFolder(wf)] as [WorkspaceFolder, URI])
                 .map(async entry => this.traverseFolder(...entry, fileExtensions, collector))
         );
-        // Only after creating all documents do we check whether we need to cancel the initialization
-        // The document builder will later pick up on all unprocessed documents
-        await interruptAndCheck(cancelToken);
-        await this.documentBuilder.build(documents, this.initialBuildOptions, cancelToken);
+        this._ready.resolve();
+        return documents;
     }
 
     /**

packages/langium/test/workspace/configuration.test.ts

@@ -14,6 +14,7 @@ describe('ConfigurationProvider', () => {
     const grammarServices = createLangiumGrammarServices(EmptyFileSystem).grammar;
     const langId = grammarServices.LanguageMetaData.languageId;
     const configs = grammarServices.shared.workspace.ConfigurationProvider;
+    configs.initialized({});
     beforeEach(() => {
         (configs as any).settings = {};
     });