#include "LibLsp/JsonRpc/json.h" #include "LibLsp/lsp/ProtocolJsonHandler.h" #include "LibLsp/lsp/ResourceOperation.h" #include "LibLsp/lsp/general/initialize.h" #include "LibLsp/lsp/general/lsTextDocumentClientCapabilities.h" #include "LibLsp/lsp/general/lsWorkspaceClientCapabilites.h" #include "LibLsp/lsp/lsp_diagnostic.h" #include "LibLsp/lsp/lsTextEdit.h" #include "LibLsp/lsp/lsWorkspaceEdit.h" #include "LibLsp/lsp/textDocument/SemanticTokens.h" #include "LibLsp/lsp/textDocument/callHierarchy.h" #include "LibLsp/lsp/textDocument/foldingRange.h" #include "LibLsp/lsp/textDocument/inlayHint.h" #include "LibLsp/lsp/textDocument/linkedEditingRange.h" #include "LibLsp/lsp/textDocument/resolveTypeHierarchy.h" #include "LibLsp/lsp/textDocument/selectionRange.h" #include "LibLsp/lsp/textDocument/typeHierarchy.h" #include "LibLsp/lsp/textDocument/hover.h" #include "LibLsp/lsp/textDocument/completion.h" #include "LibLsp/lsp/textDocument/code_lens.h" #include "LibLsp/lsp/textDocument/code_action.h" #include "LibLsp/lsp/textDocument/declaration_definition.h" #include "protocol_test_helpers.h" #include "test_helpers.h" #include #include #include #include namespace { using test::Expect; using test::ExpectParsesRequest; using test::ExpectParsesResponse; template std::string SerializeJson(T value) { rapidjson::StringBuffer buffer; rapidjson::Writer writer(buffer); JsonWriter json_writer(&writer); Reflect(json_writer, value); return buffer.GetString(); } JsonReader MakeReader(rapidjson::Document& document, char const* json) { document.Parse(json); return JsonReader(&document); } lsDocumentUri MakeDocumentUri(char const* uri) { lsDocumentUri document_uri; document_uri.raw_uri_ = uri; return document_uri; } void TestProtocolJsonHandlerRegisters316317Requests() { lsp::ProtocolJsonHandler handler; rapidjson::Document semantic_document; JsonReader semantic_reader = MakeReader( semantic_document, R"({"jsonrpc":"2.0","id":1,"method":"textDocument/semanticTokens/full","params":{"textDocument":{"uri":"file:///a.cpp"}}})"); Expect( handler.parseRequstMessage(td_semanticTokens_full::request::kMethodInfo, semantic_reader) != nullptr, "default handler must register textDocument/semanticTokens/full requests"); rapidjson::Document semantic_delta_document; JsonReader semantic_delta_reader = MakeReader( semantic_delta_document, R"({"jsonrpc":"2.0","id":2,"method":"textDocument/semanticTokens/full/delta","params":{"textDocument":{"uri":"file:///a.cpp"},"previousResultId":"prev-1"}})"); Expect( handler.parseRequstMessage(td_semanticTokens_full_delta::request::kMethodInfo, semantic_delta_reader) != nullptr, "default handler must register textDocument/semanticTokens/full/delta requests"); rapidjson::Document inlay_document; JsonReader inlay_reader = MakeReader( inlay_document, R"({"jsonrpc":"2.0","id":3,"method":"textDocument/inlayHint","params":{"textDocument":{"uri":"file:///a.cpp"},"range":{"start":{"line":0,"character":0},"end":{"line":0,"character":1}}}})"); Expect( handler.parseRequstMessage(td_inlayHint::request::kMethodInfo, inlay_reader) != nullptr, "default handler must register textDocument/inlayHint requests"); rapidjson::Document inlay_resolve_document; JsonReader inlay_resolve_reader = MakeReader( inlay_resolve_document, R"({"jsonrpc":"2.0","id":4,"method":"inlayHint/resolve","params":{"position":{"line":1,"character":2},"label":"x"}})"); Expect( handler.parseRequstMessage(td_inlayHintResolve::request::kMethodInfo, inlay_resolve_reader) != nullptr, "default handler must register inlayHint/resolve requests"); ExpectParsesRequest( handler, td_codeLens::request::kMethodInfo, R"({"jsonrpc":"2.0","id":5,"method":"textDocument/codeLens","params":{"textDocument":{"uri":"file:///a.cpp"}}})", "default handler must parse textDocument/codeLens requests"); ExpectParsesRequest( handler, td_declaration::request::kMethodInfo, R"({"jsonrpc":"2.0","id":6,"method":"textDocument/declaration","params":{"textDocument":{"uri":"file:///a.cpp"},"position":{"line":0,"character":0}}})", "default handler must parse textDocument/declaration requests"); ExpectParsesRequest( handler, td_foldingRange::request::kMethodInfo, R"({"jsonrpc":"2.0","id":7,"method":"textDocument/foldingRange","params":{"textDocument":{"uri":"file:///a.cpp"}}})", "default handler must parse textDocument/foldingRange requests"); } void TestProtocolJsonHandlerParses316317Responses() { lsp::ProtocolJsonHandler handler; rapidjson::Document folding_document; JsonReader folding_reader = MakeReader( folding_document, R"({"jsonrpc":"2.0","id":10,"result":[{"startLine":0,"endLine":2}]})"); Expect( handler.parseResponseMessage(td_foldingRange::request::kMethodInfo, folding_reader) != nullptr, "default handler must parse textDocument/foldingRange responses"); rapidjson::Document selection_document; JsonReader selection_reader = MakeReader( selection_document, R"({"jsonrpc":"2.0","id":11,"result":[{"range":{"start":{"line":0,"character":0},"end":{"line":0,"character":5}}}]})"); Expect( handler.parseResponseMessage(td_selectionRange::request::kMethodInfo, selection_reader) != nullptr, "default handler must parse textDocument/selectionRange responses"); rapidjson::Document type_hierarchy_document; JsonReader type_hierarchy_reader = MakeReader( type_hierarchy_document, R"({"jsonrpc":"2.0","id":12,"result":{"name":"Base","kind":5,"uri":"file:///a.cpp","range":{"start":{"line":0,"character":0},"end":{"line":0,"character":4}},"selectionRange":{"start":{"line":0,"character":0},"end":{"line":0,"character":4}}}})"); Expect( handler.parseResponseMessage(td_typeHierarchy::request::kMethodInfo, type_hierarchy_reader) != nullptr, "default handler must parse textDocument/typeHierarchy responses"); rapidjson::Document resolve_document; JsonReader resolve_reader = MakeReader( resolve_document, R"({"jsonrpc":"2.0","id":13,"result":{"name":"Derived","kind":5,"uri":"file:///a.cpp","range":{"start":{"line":1,"character":0},"end":{"line":1,"character":7}},"selectionRange":{"start":{"line":1,"character":0},"end":{"line":1,"character":7}}}})"); Expect( handler.parseResponseMessage(typeHierarchy_resolve::request::kMethodInfo, resolve_reader) != nullptr, "default handler must parse typeHierarchy/resolve responses"); ExpectParsesResponse( handler, td_semanticTokens_full::request::kMethodInfo, R"({"jsonrpc":"2.0","id":14,"result":{"data":[0,1,2,3,4]}})", "default handler must parse textDocument/semanticTokens/full responses"); ExpectParsesResponse( handler, td_inlayHint::request::kMethodInfo, R"({"jsonrpc":"2.0","id":15,"result":[{"position":{"line":0,"character":0},"label":"hint"}]})", "default handler must parse textDocument/inlayHint responses"); ExpectParsesResponse( handler, td_codeLens::request::kMethodInfo, R"({"jsonrpc":"2.0","id":16,"result":[{"range":{"start":{"line":0,"character":0},"end":{"line":0,"character":1}}}]})", "default handler must parse textDocument/codeLens responses"); ExpectParsesResponse( handler, td_completion::request::kMethodInfo, R"({"jsonrpc":"2.0","id":17,"result":{"isIncomplete":false,"items":[]}})", "default handler must parse textDocument/completion responses"); ExpectParsesResponse( handler, td_hover::request::kMethodInfo, R"({"jsonrpc":"2.0","id":18,"result":{"contents":"doc"}})", "default handler must parse textDocument/hover responses"); ExpectParsesResponse( handler, td_codeAction::request::kMethodInfo, R"({"jsonrpc":"2.0","id":19,"result":[{"title":"Fix","command":"cmd.fix"}]})", "default handler must parse textDocument/codeAction responses"); ExpectParsesResponse( handler, td_declaration::request::kMethodInfo, R"({"jsonrpc":"2.0","id":20,"result":[{"uri":"file:///a.cpp","range":{"start":{"line":0,"character":0},"end":{"line":0,"character":1}}}]})", "default handler must parse textDocument/declaration responses"); } void Test316ModelsSerializeExpectedFields() { lsChangeAnnotation annotation; annotation.label = "Rename symbol"; annotation.needsConfirmation = true; annotation.description = "Updates all references"; std::string const annotation_json = SerializeJson(annotation); Expect(annotation_json.find("\"label\":\"Rename symbol\"") != std::string::npos, "change annotation must serialize label"); Expect( annotation_json.find("\"needsConfirmation\":true") != std::string::npos, "change annotation must serialize needsConfirmation"); lsWorkspaceEdit workspace_edit; workspace_edit.changeAnnotations = lsChangeAnnotations(); workspace_edit.changeAnnotations->id.label = "Grouped edit"; std::string const workspace_edit_json = SerializeJson(workspace_edit); Expect( workspace_edit_json.find("\"changeAnnotations\"") != std::string::npos, "workspace edit must serialize changeAnnotations"); lsTextEdit text_edit; text_edit.range.start.line = 0; text_edit.range.start.character = 0; text_edit.range.end.line = 0; text_edit.range.end.character = 1; text_edit.newText = "x"; text_edit.annotationId = std::string("edit-1"); Expect( SerializeJson(text_edit).find("\"annotationId\":\"edit-1\"") != std::string::npos, "text edit must serialize annotationId"); lsDiagnostic diagnostic; diagnostic.range.start.line = 1; diagnostic.range.start.character = 2; diagnostic.range.end.line = 1; diagnostic.range.end.character = 5; diagnostic.message = "unused variable"; diagnostic.codeDescription = DiagnosticCodeDescription(); diagnostic.codeDescription->href = "https://example.com/diag"; diagnostic.data = lsp::Any(); diagnostic.data->SetJsonString(R"({"owner":"test"})", lsp::Any::kObjectType); std::string const diagnostic_json = SerializeJson(diagnostic); Expect( diagnostic_json.find("\"codeDescription\"") != std::string::npos, "diagnostic must serialize codeDescription"); Expect(diagnostic_json.find("\"data\"") != std::string::npos, "diagnostic must serialize data"); SemanticTokens tokens; tokens.resultId = std::string("tok-42"); tokens.data = {0, 1, 2, 3, 4}; std::string const tokens_json = SerializeJson(tokens); Expect(tokens_json.find("\"resultId\":\"tok-42\"") != std::string::npos, "semantic tokens must serialize resultId"); Expect(tokens_json.find("\"data\"") != std::string::npos, "semantic tokens must serialize data"); SemanticTokensDeltaParams delta_params; delta_params.textDocument.uri = MakeDocumentUri("file:///a.cpp"); delta_params.previousResultId = "tok-42"; Expect( SerializeJson(delta_params).find("\"previousResultId\":\"tok-42\"") != std::string::npos, "semantic tokens delta params must serialize previousResultId"); CallHierarchyItem call_item; call_item.name = "foo"; call_item.kind = SymbolKind::Function; call_item.uri = MakeDocumentUri("file:///a.cpp"); call_item.range.start.line = 0; call_item.range.end.line = 0; call_item.selectionRange.start.line = 0; call_item.selectionRange.end.line = 0; call_item.tags = std::vector{SymbolTag::Deprecated}; Expect( SerializeJson(call_item).find("\"tags\"") != std::string::npos, "call hierarchy item must serialize tags"); LinkedEditingRanges linked_ranges; linked_ranges.ranges.push_back(lsRange()); linked_ranges.wordPattern = std::string("[a-z]+"); Expect( SerializeJson(linked_ranges).find("\"wordPattern\":\"[a-z]+\"") != std::string::npos, "linked editing ranges must serialize wordPattern"); FoldingRange folding_range; folding_range.startLine = 0; folding_range.endLine = 3; folding_range.kind = "comment"; Expect( SerializeJson(folding_range).find("\"kind\":\"comment\"") != std::string::npos, "folding range must serialize kind"); lsCreateFile create_file; create_file.uri = MakeDocumentUri("file:///new.cpp"); create_file.annotationId = std::string("create-1"); Expect( SerializeJson(create_file).find("\"annotationId\":\"create-1\"") != std::string::npos, "create file operation must serialize annotationId"); } void Test317ModelsSerializeExpectedFields() { lsInlayHintLabelPart label_part; label_part.value = "count"; label_part.tooltip = std::string("parameter name"); Expect( SerializeJson(label_part).find("\"tooltip\":\"parameter name\"") != std::string::npos, "inlay hint label part must serialize tooltip"); lsInlayHint hint; hint.position.line = 2; hint.position.character = 4; hint.label = "count"; hint.kind = lsInlayHintKind::Parameter; hint.paddingLeft = true; hint.paddingRight = false; std::string const hint_json = SerializeJson(hint); Expect(hint_json.find("\"kind\":2") != std::string::npos, "inlay hint must serialize kind"); Expect(hint_json.find("\"paddingLeft\":true") != std::string::npos, "inlay hint must serialize paddingLeft"); Expect(hint_json.find("\"paddingRight\":false") != std::string::npos, "inlay hint must serialize paddingRight"); } void TestCapabilitiesSerialize316317Fields() { lsServerCapabilities server_capabilities; server_capabilities.semanticTokensProvider = SemanticTokensWithRegistrationOptions(); server_capabilities.semanticTokensProvider->legend.tokenTypes.push_back("function"); server_capabilities.semanticTokensProvider->legend.tokenModifiers.push_back("deprecated"); server_capabilities.callHierarchyProvider = std::make_pair(optional(true), optional()); server_capabilities.linkedEditingRangeProvider = std::make_pair(optional(true), optional()); InlayHintOptions inlay_hint_options; inlay_hint_options.resolveProvider = true; server_capabilities.inlayHintProvider = std::make_pair(optional(), optional(inlay_hint_options)); server_capabilities.workspace = WorkspaceServerCapabilities(); server_capabilities.workspace->fileOperations = WorkspaceServerCapabilities::lsFileOperations(); server_capabilities.workspace->fileOperations->willCreate = lsFileOperationRegistrationOptions(); std::string const server_json = SerializeJson(server_capabilities); Expect( server_json.find("\"semanticTokensProvider\"") != std::string::npos, "server capabilities must expose semanticTokensProvider"); Expect( server_json.find("\"callHierarchyProvider\"") != std::string::npos, "server capabilities must expose callHierarchyProvider"); Expect( server_json.find("\"linkedEditingRangeProvider\"") != std::string::npos, "server capabilities must expose linkedEditingRangeProvider"); Expect(server_json.find("\"inlayHintProvider\"") != std::string::npos, "server capabilities must expose inlayHintProvider"); Expect(server_json.find("\"resolveProvider\":true") != std::string::npos, "inlay hint provider must expose resolveProvider"); Expect(server_json.find("\"fileOperations\"") != std::string::npos, "workspace capabilities must expose fileOperations"); lsTextDocumentClientCapabilities text_document_capabilities; text_document_capabilities.semanticTokens = SemanticTokensClientCapabilities(); text_document_capabilities.semanticTokens->tokenTypes.push_back("variable"); text_document_capabilities.semanticTokens->multilineTokenSupport = true; text_document_capabilities.inlayHint = InlayHintClientCapabilities(); text_document_capabilities.inlayHint->resolveSupport = InlayHintLazyProperties(); text_document_capabilities.inlayHint->resolveSupport->properties = std::vector{"tooltip"}; text_document_capabilities.foldingRange = FoldingRangeCapabilities(); text_document_capabilities.foldingRange->lineFoldingOnly = true; text_document_capabilities.publishDiagnostics = PublishDiagnosticsClientCapabilities(); text_document_capabilities.publishDiagnostics->codeDescriptionSupport = true; text_document_capabilities.publishDiagnostics->dataSupport = true; std::string const client_json = SerializeJson(text_document_capabilities); Expect(client_json.find("\"semanticTokens\"") != std::string::npos, "text document capabilities must expose semanticTokens"); Expect( client_json.find("\"multilineTokenSupport\":true") != std::string::npos, "semantic tokens client capabilities must expose multilineTokenSupport"); Expect(client_json.find("\"inlayHint\"") != std::string::npos, "text document capabilities must expose inlayHint"); Expect(client_json.find("\"resolveSupport\"") != std::string::npos, "inlay hint client capabilities must expose resolveSupport"); Expect(client_json.find("\"lineFoldingOnly\":true") != std::string::npos, "folding range capabilities must expose lineFoldingOnly"); Expect( client_json.find("\"codeDescriptionSupport\":true") != std::string::npos, "publish diagnostics capabilities must expose codeDescriptionSupport"); Expect( client_json.find("\"dataSupport\":true") != std::string::npos, "publish diagnostics capabilities must expose dataSupport"); } void TestClangdDerived316RequestFixturesParse() { lsp::ProtocolJsonHandler handler; test::ExpectParsesRequest( handler, td_foldingRange::request::kMethodInfo, test::ReadFixture("folding_range_request.json").c_str(), "clangd-derived foldingRange request fixture must parse"); rapidjson::Document selection_document; selection_document.Parse(test::ReadFixture("selection_range_request.json").c_str()); JsonReader selection_reader(&selection_document); Expect( td_selectionRange::request::ReflectReader(selection_reader) != nullptr, "clangd-derived selectionRange request fixture must parse"); } } // namespace int main(int argc, char** argv) { test::InitTestFilter(argc, argv); RUN_TEST(TestProtocolJsonHandlerRegisters316317Requests); RUN_TEST(TestProtocolJsonHandlerParses316317Responses); RUN_TEST(Test316ModelsSerializeExpectedFields); RUN_TEST(Test317ModelsSerializeExpectedFields); RUN_TEST(TestCapabilitiesSerialize316317Fields); RUN_TEST(TestClangdDerived316RequestFixturesParse); return test::Failures() == 0 ? 0 : 1; } .