Function setupCompletion

packages/monaco/src/lsp.ts:247–304

(
    documentUri: string,
    languageId: string,
    connection: ProtocolConnection,
    initResponse: InitializeResult<any>
)

    });
}
function setupCompletion(
    documentUri: string,
    languageId: string,
    connection: ProtocolConnection,
    initResponse: InitializeResult<any>
) {
    if (!initResponse.capabilities.completionProvider) {
        return;
    }

    // TODO: registration is global, this will break with multiple editors
    monaco.languages.registerCompletionItemProvider(languageId, {
        triggerCharacters: initResponse.capabilities.completionProvider!.triggerCharacters,
        async provideCompletionItems(_, position, context, token) {
            const params: CompletionParams = {
                position: {
                    line: position.lineNumber - 1,
                    character: position.column - 1
                },
                textDocument: {
                    uri: documentUri
                },
                context: {
                    triggerKind: monacoToLspCompletionTriggerKind(context.triggerKind),
                    triggerCharacter: context.triggerCharacter
                }
            };
            const response = await connection.sendRequest(CompletionRequest.type, params, token);
            if (response === null) {
                return null;
            }
            const range: monaco.Range = new monaco.Range(
                position.lineNumber,
                position.column,
                position.lineNumber,
                position.column
            );

            return Array.isArray(response)
                ? {
                      suggestions: response.map(r => lspToMonacoCompletionItem(r, range)),
                      incomplete: false
                  }
                : {
                      suggestions: response.items.map(r => lspToMonacoCompletionItem(r, range)),
                      incomplete: response.isIncomplete
                  };
        },
        async resolveCompletionItem(item, token) {
            const response = await connection.sendRequest(
                CompletionResolveRequest.type,
                monacoToLspCompletionItem(item),
                token
            );
            return lspToMonacoCompletionItem(response, item.range);
        }
    });
}