langium/lsp: externalized LSP service minimum document state configs into the DI modules

* relaxed some doc state requirements to increase the LS' responsiveness from 'IndexedReferences' to 'Linked' as it is sufficient that all required documents are in state 'ComputedScopes', and current document should (ideally) be linked:
   completion, declaration, definition, implementation, typeDefinition, hover, semanticToken

Author: sailingKieler

packages/langium/src/lsp/default-lsp-module.ts

@@ -8,7 +8,7 @@ import type { Connection } from 'vscode-languageserver';
 import { createDefaultCoreModule, createDefaultSharedCoreModule, type DefaultCoreModuleContext, type DefaultSharedCoreModuleContext } from '../default-module.js';
 import { Module } from '../dependency-injection.js';
 import type { LangiumDefaultCoreServices, LangiumDefaultSharedCoreServices } from '../services.js';
-import { TextDocument } from '../workspace/documents.js';
+import { DocumentState, TextDocument } from '../workspace/documents.js';
 import { DefaultCompletionProvider } from './completion/completion-provider.js';
 import { DefaultDefinitionProvider } from './definition-provider.js';
 import { DefaultDocumentHighlightProvider } from './document-highlight-provider.js';
@@ -94,6 +94,29 @@ export function createDefaultSharedLSPModule(context: DefaultSharedModuleContext
             WorkspaceSymbolProvider: (services) => new DefaultWorkspaceSymbolProvider(services),
             NodeKindProvider: () => new DefaultNodeKindProvider(),
             FuzzyMatcher: () => new DefaultFuzzyMatcher(),
+            serviceRequirements: {
+                CallHierarchyProvider: DocumentState.IndexedReferences,
+                CodeActionProvider: DocumentState.Validated,
+                CodeLensProvider: DocumentState.IndexedReferences,
+                CompletionProvider: DocumentState.Linked,
+                DeclarationProvider: DocumentState.Linked,
+                DefinitionProvider: DocumentState.Linked,
+                DocumentHighlightProvider: DocumentState.IndexedReferences,
+                DocumentLinkProvider: DocumentState.Parsed,
+                DocumentSymbolProvider: DocumentState.Parsed,
+                FoldingRangeProvider: DocumentState.Parsed,
+                Formatter: DocumentState.Parsed,
+                HoverProvider: DocumentState.Linked,
+                ImplementationProvider: DocumentState.Linked,
+                InlayHintProvider: DocumentState.IndexedReferences,
+                ReferencesProvider: DocumentState.IndexedReferences,
+                RenameProvider: DocumentState.IndexedReferences,
+                SemanticTokenProvider: DocumentState.Linked,
+                SignatureHelp: DocumentState. IndexedReferences,
+                TypeHierarchyProvider: DocumentState.IndexedReferences,
+                TypeProvider: DocumentState.Linked,
+                WorkspaceSymbolProvider: DocumentState.IndexedContent
+            }
         },
         workspace: {
             TextDocuments: () => new NormalizedTextDocuments(TextDocument),

packages/langium/src/lsp/language-server.ts

@@ -349,130 +349,136 @@ export function addCompletionHandler(connection: Connection, services: LangiumSh
             return services.lsp?.CompletionProvider?.getCompletion(document, params, cancelToken);
         },
         services,
-        DocumentState.IndexedReferences
+        services.lsp.serviceRequirements.CompletionProvider
     ));
 }
 
 export function addFindReferencesHandler(connection: Connection, services: LangiumSharedServices): void {
     connection.onReferences(createRequestHandler(
         (services, document, params, cancelToken) => services.lsp?.ReferencesProvider?.findReferences(document, params, cancelToken),
         services,
-        DocumentState.IndexedReferences
+        services.lsp.serviceRequirements.ReferencesProvider
     ));
 }
 
 export function addCodeActionHandler(connection: Connection, services: LangiumSharedServices): void {
     connection.onCodeAction(createRequestHandler(
         (services, document, params, cancelToken) => services.lsp?.CodeActionProvider?.getCodeActions(document, params, cancelToken),
         services,
-        DocumentState.Validated
+        services.lsp.serviceRequirements.CodeActionProvider
     ));
 }
 
 export function addDocumentSymbolHandler(connection: Connection, services: LangiumSharedServices): void {
     connection.onDocumentSymbol(createRequestHandler(
         (services, document, params, cancelToken) => services.lsp?.DocumentSymbolProvider?.getSymbols(document, params, cancelToken),
         services,
-        DocumentState.Parsed
+        services.lsp.serviceRequirements.DocumentSymbolProvider
     ));
 }
 
 export function addGotoDefinitionHandler(connection: Connection, services: LangiumSharedServices): void {
     connection.onDefinition(createRequestHandler(
         (services, document, params, cancelToken) => services.lsp?.DefinitionProvider?.getDefinition(document, params, cancelToken),
         services,
-        DocumentState.IndexedReferences
+        services.lsp.serviceRequirements.DefinitionProvider
     ));
 }
 
 export function addGoToTypeDefinitionHandler(connection: Connection, services: LangiumSharedServices): void {
     connection.onTypeDefinition(createRequestHandler(
         (services, document, params, cancelToken) => services.lsp?.TypeProvider?.getTypeDefinition(document, params, cancelToken),
         services,
-        DocumentState.IndexedReferences
+        services.lsp.serviceRequirements.TypeProvider
     ));
 }
 
 export function addGoToImplementationHandler(connection: Connection, services: LangiumSharedServices) {
     connection.onImplementation(createRequestHandler(
         (services, document, params, cancelToken) => services.lsp?.ImplementationProvider?.getImplementation(document, params, cancelToken),
         services,
-        DocumentState.IndexedReferences
+        services.lsp.serviceRequirements.ImplementationProvider
     ));
 }
 
 export function addGoToDeclarationHandler(connection: Connection, services: LangiumSharedServices) {
     connection.onDeclaration(createRequestHandler(
         (services, document, params, cancelToken) => services.lsp?.DeclarationProvider?.getDeclaration(document, params, cancelToken),
         services,
-        DocumentState.IndexedReferences
+        services.lsp.serviceRequirements.DeclarationProvider
     ));
 }
 
 export function addDocumentHighlightsHandler(connection: Connection, services: LangiumSharedServices): void {
     connection.onDocumentHighlight(createRequestHandler(
         (services, document, params, cancelToken) => services.lsp?.DocumentHighlightProvider?.getDocumentHighlight(document, params, cancelToken),
         services,
-        DocumentState.IndexedReferences
+        services.lsp.serviceRequirements.DocumentHighlightProvider
     ));
 }
 
 export function addHoverHandler(connection: Connection, services: LangiumSharedServices): void {
     connection.onHover(createRequestHandler(
         (services, document, params, cancelToken) => services.lsp?.HoverProvider?.getHoverContent(document, params, cancelToken),
         services,
-        DocumentState.IndexedReferences
+        services.lsp.serviceRequirements.HoverProvider
     ));
 }
 
 export function addFoldingRangeHandler(connection: Connection, services: LangiumSharedServices): void {
     connection.onFoldingRanges(createRequestHandler(
         (services, document, params, cancelToken) => services.lsp?.FoldingRangeProvider?.getFoldingRanges(document, params, cancelToken),
         services,
-        DocumentState.Parsed
+        services.lsp.serviceRequirements.FoldingRangeProvider
     ));
 }
 
 export function addFormattingHandler(connection: Connection, services: LangiumSharedServices): void {
+    const targetState = services.lsp.serviceRequirements.Formatter;
+
     connection.onDocumentFormatting(createRequestHandler(
         (services, document, params, cancelToken) => services.lsp?.Formatter?.formatDocument(document, params, cancelToken),
         services,
-        DocumentState.Parsed
+        targetState
     ));
     connection.onDocumentRangeFormatting(createRequestHandler(
         (services, document, params, cancelToken) => services.lsp?.Formatter?.formatDocumentRange(document, params, cancelToken),
         services,
-        DocumentState.Parsed
+        targetState
     ));
     connection.onDocumentOnTypeFormatting(createRequestHandler(
         (services, document, params, cancelToken) => services.lsp?.Formatter?.formatDocumentOnType(document, params, cancelToken),
         services,
-        DocumentState.Parsed
+        targetState
     ));
 }
 
 export function addRenameHandler(connection: Connection, services: LangiumSharedServices): void {
+    const targetState = services.lsp.serviceRequirements.RenameProvider;
+
     connection.onRenameRequest(createRequestHandler(
         (services, document, params, cancelToken) => services.lsp?.RenameProvider?.rename(document, params, cancelToken),
         services,
-        DocumentState.IndexedReferences
+        targetState
     ));
     connection.onPrepareRename(createRequestHandler(
         (services, document, params, cancelToken) => services.lsp?.RenameProvider?.prepareRename(document, params, cancelToken),
         services,
-        DocumentState.IndexedReferences
+        targetState
     ));
 }
 
 export function addInlayHintHandler(connection: Connection, services: LangiumSharedServices): void {
     connection.languages.inlayHint.on(createServerRequestHandler(
         (services, document, params, cancelToken) => services.lsp?.InlayHintProvider?.getInlayHints(document, params, cancelToken),
         services,
-        DocumentState.IndexedReferences
+        services.lsp.serviceRequirements.InlayHintProvider
     ));
 }
 
 export function addSemanticTokenHandler(connection: Connection, services: LangiumSharedServices): void {
+    const targetState = services.lsp.serviceRequirements.SemanticTokenProvider;
+
     // If no semantic token provider is registered that's fine. Just return an empty result
     const emptyResult: SemanticTokens = { data: [] };
     connection.languages.semanticTokens.on(createServerRequestHandler<SemanticTokensParams, SemanticTokens, SemanticTokensPartialResult, void>(
@@ -483,7 +489,7 @@ export function addSemanticTokenHandler(connection: Connection, services: Langiu
             return emptyResult;
         },
         services,
-        DocumentState.IndexedReferences
+        targetState
     ));
     connection.languages.semanticTokens.onDelta(createServerRequestHandler<SemanticTokensDeltaParams, SemanticTokens | SemanticTokensDelta, SemanticTokensDeltaPartialResult, void>(
         (services, document, params, cancelToken) => {
@@ -493,7 +499,7 @@ export function addSemanticTokenHandler(connection: Connection, services: Langiu
             return emptyResult;
         },
         services,
-        DocumentState.IndexedReferences
+        targetState
     ));
     connection.languages.semanticTokens.onRange(createServerRequestHandler<SemanticTokensRangeParams, SemanticTokens, SemanticTokensPartialResult, void>(
         (services, document, params, cancelToken) => {
@@ -503,7 +509,7 @@ export function addSemanticTokenHandler(connection: Connection, services: Langiu
             return emptyResult;
         },
         services,
-        DocumentState.IndexedReferences
+        targetState
     ));
 }
 export function addConfigurationChangeHandler(connection: Connection, services: LangiumSharedServices): void {
@@ -529,33 +535,35 @@ export function addDocumentLinkHandler(connection: Connection, services: Langium
     connection.onDocumentLinks(createServerRequestHandler(
         (services, document, params, cancelToken) => services.lsp?.DocumentLinkProvider?.getDocumentLinks(document, params, cancelToken),
         services,
-        DocumentState.Parsed
+        services.lsp.serviceRequirements.DocumentLinkProvider
     ));
 }
 
 export function addSignatureHelpHandler(connection: Connection, services: LangiumSharedServices): void {
     connection.onSignatureHelp(createServerRequestHandler(
         (services, document, params, cancelToken) => services.lsp?.SignatureHelp?.provideSignatureHelp(document, params, cancelToken),
         services,
-        DocumentState.IndexedReferences
+        services.lsp.serviceRequirements.SignatureHelp
     ));
 }
 
 export function addCodeLensHandler(connection: Connection, services: LangiumSharedServices): void {
     connection.onCodeLens(createServerRequestHandler(
         (services, document, params, cancelToken) => services.lsp?.CodeLensProvider?.provideCodeLens(document, params, cancelToken),
         services,
-        DocumentState.IndexedReferences
+        services.lsp.serviceRequirements.CodeLensProvider
     ));
 }
 
 export function addWorkspaceSymbolHandler(connection: Connection, services: LangiumSharedServices): void {
     const workspaceSymbolProvider = services.lsp.WorkspaceSymbolProvider;
     if (workspaceSymbolProvider) {
+        const targetState = services.lsp.serviceRequirements.WorkspaceSymbolProvider;
+
         const documentBuilder = services.workspace.DocumentBuilder;
         connection.onWorkspaceSymbol(async (params, token) => {
             try {
-                await documentBuilder.waitUntil(DocumentState.IndexedContent, token);
+                await documentBuilder.waitUntil(targetState, token);
                 return await workspaceSymbolProvider.getSymbols(params, token);
             } catch (err) {
                 return responseError(err);
@@ -565,7 +573,7 @@ export function addWorkspaceSymbolHandler(connection: Connection, services: Lang
         if (resolveWorkspaceSymbol) {
             connection.onWorkspaceSymbolResolve(async (workspaceSymbol, token) => {
                 try {
-                    await documentBuilder.waitUntil(DocumentState.IndexedContent, token);
+                    await documentBuilder.waitUntil(targetState, token);
                     return await resolveWorkspaceSymbol(workspaceSymbol, token);
                 } catch (err) {
                     return responseError(err);
@@ -576,6 +584,8 @@ export function addWorkspaceSymbolHandler(connection: Connection, services: Lang
 }
 
 export function addCallHierarchyHandler(connection: Connection, services: LangiumSharedServices): void {
+    const targetState = services.lsp.serviceRequirements.CallHierarchyProvider;
+
     connection.languages.callHierarchy.onPrepare(createServerRequestHandler(
         async (services, document, params, cancelToken) => {
             if (services.lsp?.CallHierarchyProvider) {
@@ -585,7 +595,7 @@ export function addCallHierarchyHandler(connection: Connection, services: Langiu
             return null;
         },
         services,
-        DocumentState.IndexedReferences
+        targetState
     ));
 
     connection.languages.callHierarchy.onIncomingCalls(createHierarchyRequestHandler(
@@ -596,7 +606,8 @@ export function addCallHierarchyHandler(connection: Connection, services: Langiu
             }
             return null;
         },
-        services
+        services,
+        targetState
     ));
 
     connection.languages.callHierarchy.onOutgoingCalls(createHierarchyRequestHandler(
@@ -607,7 +618,8 @@ export function addCallHierarchyHandler(connection: Connection, services: Langiu
             }
             return null;
         },
-        services
+        services,
+        targetState
     ));
 }
 
@@ -617,14 +629,16 @@ export function addTypeHierarchyHandler(connection: Connection, sharedServices:
         return;
     }
 
+    const targetState = sharedServices.lsp.serviceRequirements.TypeHierarchyProvider;
+
     connection.languages.typeHierarchy.onPrepare(
         createServerRequestHandler(
             async (services, document, params, cancelToken) => {
                 const result = await services.lsp?.TypeHierarchyProvider?.prepareTypeHierarchy(document, params, cancelToken);
                 return result ?? null;
             },
             sharedServices,
-            DocumentState.IndexedReferences
+            targetState
         ),
     );
 
@@ -634,7 +648,8 @@ export function addTypeHierarchyHandler(connection: Connection, sharedServices:
                 const result = await services.lsp?.TypeHierarchyProvider?.supertypes(params, cancelToken);
                 return result ?? null;
             },
-            sharedServices
+            sharedServices,
+            targetState
         ),
     );
 
@@ -644,19 +659,21 @@ export function addTypeHierarchyHandler(connection: Connection, sharedServices:
                 const result = await services.lsp?.TypeHierarchyProvider?.subtypes(params, cancelToken);
                 return result ?? null;
             },
-            sharedServices
+            sharedServices,
+            targetState
         ),
     );
 }
 
 export function createHierarchyRequestHandler<P extends TypeHierarchySupertypesParams | TypeHierarchySubtypesParams | CallHierarchyIncomingCallsParams | CallHierarchyOutgoingCallsParams, R, PR, E = void>(
     serviceCall: (services: LangiumCoreAndPartialLSPServices, params: P, cancelToken: CancellationToken) => HandlerResult<R, E>,
     sharedServices: LangiumSharedServices,
+    targetState: DocumentState
 ): ServerRequestHandler<P, R, PR, E> {
     const serviceRegistry = sharedServices.ServiceRegistry;
     return async (params: P, cancelToken: CancellationToken) => {
         const uri = URI.parse(params.item.uri);
-        const cancellationError = await waitUntilPhase<E>(sharedServices, cancelToken, uri, DocumentState.IndexedReferences);
+        const cancellationError = await waitUntilPhase<E>(sharedServices, cancelToken, uri, targetState);
         if (cancellationError) {
             return cancellationError;
         }

packages/langium/src/lsp/lsp-services.ts

@@ -6,7 +6,7 @@
 
 import type { Connection } from 'vscode-languageserver';
 import type { DeepPartial, LangiumCoreServices, LangiumSharedCoreServices } from '../services.js';
-import type { TextDocument } from '../workspace/documents.js';
+import type { DocumentState, TextDocument } from '../workspace/documents.js';
 import type { CallHierarchyProvider } from './call-hierarchy-provider.js';
 import type { CodeActionProvider } from './code-action.js';
 import type { CodeLensProvider } from './code-lens-provider.js';
@@ -88,6 +88,29 @@ export type LangiumSharedLSPServices = {
         readonly LanguageServer: LanguageServer
         readonly NodeKindProvider: NodeKindProvider
         readonly WorkspaceSymbolProvider?: WorkspaceSymbolProvider
+        readonly serviceRequirements: {
+            readonly CallHierarchyProvider: DocumentState
+            readonly CodeActionProvider: DocumentState
+            readonly CodeLensProvider: DocumentState
+            readonly CompletionProvider: DocumentState
+            readonly DeclarationProvider: DocumentState
+            readonly DefinitionProvider: DocumentState
+            readonly DocumentHighlightProvider: DocumentState
+            readonly DocumentLinkProvider: DocumentState
+            readonly DocumentSymbolProvider: DocumentState
+            readonly FoldingRangeProvider: DocumentState
+            readonly Formatter: DocumentState
+            readonly HoverProvider: DocumentState
+            readonly ImplementationProvider: DocumentState
+            readonly InlayHintProvider: DocumentState
+            readonly ReferencesProvider: DocumentState
+            readonly RenameProvider: DocumentState
+            readonly SemanticTokenProvider: DocumentState
+            readonly SignatureHelp: DocumentState
+            readonly TypeHierarchyProvider: DocumentState
+            readonly TypeProvider: DocumentState
+            readonly WorkspaceSymbolProvider: DocumentState
+        }
     },
     readonly workspace: {
         readonly TextDocuments: TextDocuments<TextDocument>