csh/tsl-devkit
1
1
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

🔧 chore(lsp_server): gate providers to completion/definition

Browse Source 
Initialize now advertises only completion (resolve) and definition.

Verified: test_provider (clang-linux-server/Release)
This commit is contained in:
csh
2025-12-24 11:33:40 +08:00
parent 09e65224fe
commit 02864dda89
3 changed files with 81 additions and 275 deletions
Download Patch File Download Diff File Expand all files Collapse all files
lsp-server/test/test_provider/provider_misc_test.cppm
+6 -94
View File
@@ -420,100 +420,12 @@ namespace lsp::test::provider
}
assertTrue(capabilities.find("definitionProvider") != capabilities.end(), "Initialize should enable definitionProvider");
assertTrue(capabilities.find("typeDefinitionProvider") != capabilities.end(), "Initialize should enable typeDefinitionProvider");
assertTrue(capabilities.find("implementationProvider") != capabilities.end(), "Initialize should enable implementationProvider");
assertTrue(capabilities.find("hoverProvider") != capabilities.end(), "Initialize should enable hoverProvider");
assertTrue(capabilities.find("signatureHelpProvider") != capabilities.end(), "Initialize should enable signatureHelpProvider");
assertTrue(capabilities.find("codeActionProvider") != capabilities.end(), "Initialize should enable codeActionProvider");
auto call_hierarchy_it = capabilities.find("callHierarchyProvider");
assertTrue(call_hierarchy_it != capabilities.end(), "Initialize should enable callHierarchyProvider");
if (call_hierarchy_it != capabilities.end())
{
assertTrue(call_hierarchy_it->second.Is<protocol::boolean>() && call_hierarchy_it->second.Get<protocol::boolean>(),
"callHierarchyProvider should be enabled");
}
auto type_hierarchy_it = capabilities.find("typeHierarchyProvider");
assertTrue(type_hierarchy_it != capabilities.end(), "Initialize should enable typeHierarchyProvider");
if (type_hierarchy_it != capabilities.end())
{
assertTrue(type_hierarchy_it->second.Is<protocol::boolean>() && type_hierarchy_it->second.Get<protocol::boolean>(),
"typeHierarchyProvider should be enabled");
}
assertTrue(capabilities.find("referencesProvider") != capabilities.end(), "Initialize should enable referencesProvider");
assertTrue(capabilities.find("documentHighlightProvider") != capabilities.end(), "Initialize should enable documentHighlightProvider");
assertTrue(capabilities.find("documentSymbolProvider") != capabilities.end(), "Initialize should enable documentSymbolProvider");
assertTrue(capabilities.find("workspaceSymbolProvider") != capabilities.end(), "Initialize should enable workspaceSymbolProvider");
assertTrue(capabilities.find("semanticTokensProvider") != capabilities.end(), "Initialize should enable semanticTokensProvider");
auto document_link_it = capabilities.find("documentLinkProvider");
assertTrue(document_link_it != capabilities.end(), "Initialize should enable documentLinkProvider");
if (document_link_it != capabilities.end() && document_link_it->second.Is<protocol::LSPObject>())
{
const auto& document_link = document_link_it->second.Get<protocol::LSPObject>();
auto resolve_it = document_link.find("resolveProvider");
assertTrue(resolve_it != document_link.end(), "documentLinkProvider should include resolveProvider");
assertTrue(resolve_it->second.Is<protocol::boolean>() && resolve_it->second.Get<protocol::boolean>(),
"documentLinkProvider should enable resolveProvider");
}
assertTrue(capabilities.find("foldingRangeProvider") != capabilities.end(), "Initialize should enable foldingRangeProvider");
assertTrue(capabilities.find("selectionRangeProvider") != capabilities.end(), "Initialize should enable selectionRangeProvider");
auto inlay_hint_it = capabilities.find("inlayHintProvider");
assertTrue(inlay_hint_it != capabilities.end(), "Initialize should enable inlayHintProvider");
if (inlay_hint_it != capabilities.end() && inlay_hint_it->second.Is<protocol::LSPObject>())
{
const auto& inlay_hint = inlay_hint_it->second.Get<protocol::LSPObject>();
auto resolve_it = inlay_hint.find("resolveProvider");
assertTrue(resolve_it != inlay_hint.end(), "inlayHintProvider should include resolveProvider");
assertTrue(resolve_it->second.Is<protocol::boolean>() && resolve_it->second.Get<protocol::boolean>(),
"inlayHintProvider should enable resolveProvider");
}
auto code_lens_it = capabilities.find("codeLensProvider");
assertTrue(code_lens_it != capabilities.end(), "Initialize should enable codeLensProvider");
if (code_lens_it != capabilities.end() && code_lens_it->second.Is<protocol::LSPObject>())
{
const auto& code_lens = code_lens_it->second.Get<protocol::LSPObject>();
auto resolve_it = code_lens.find("resolveProvider");
assertTrue(resolve_it != code_lens.end(), "codeLensProvider should include resolveProvider");
assertTrue(resolve_it->second.Is<protocol::boolean>() && resolve_it->second.Get<protocol::boolean>(),
"codeLensProvider should enable resolveProvider");
}
auto rename_it = capabilities.find("renameProvider");
assertTrue(rename_it != capabilities.end(), "Initialize should enable renameProvider");
if (rename_it != capabilities.end() && rename_it->second.Is<protocol::LSPObject>())
{
const auto& rename = rename_it->second.Get<protocol::LSPObject>();
auto prepare_it = rename.find("prepareProvider");
assertTrue(prepare_it != rename.end(), "renameProvider should include prepareProvider");
assertTrue(prepare_it->second.Is<protocol::boolean>() && prepare_it->second.Get<protocol::boolean>(),
"renameProvider should enable prepareProvider");
}
auto workspace_it = capabilities.find("workspace");
assertTrue(workspace_it != capabilities.end(), "Initialize should include workspace capabilities");
if (workspace_it != capabilities.end() && workspace_it->second.Is<protocol::LSPObject>())
{
const auto& workspace = workspace_it->second.Get<protocol::LSPObject>();
auto file_ops_it = workspace.find("fileOperations");
assertTrue(file_ops_it != workspace.end(), "workspace should include fileOperations");
assertTrue(file_ops_it->second.Is<protocol::LSPObject>(), "fileOperations should be an object");
const auto& file_ops = file_ops_it->second.Get<protocol::LSPObject>();
auto did_create_it = file_ops.find("didCreate");
assertTrue(did_create_it != file_ops.end(), "fileOperations should include didCreate");
assertTrue(did_create_it->second.Is<protocol::boolean>() && did_create_it->second.Get<protocol::boolean>(),
"fileOperations.didCreate should be enabled");
auto did_delete_it = file_ops.find("didDelete");
assertTrue(did_delete_it != file_ops.end(), "fileOperations should include didDelete");
assertTrue(did_delete_it->second.Is<protocol::boolean>() && did_delete_it->second.Get<protocol::boolean>(),
"fileOperations.didDelete should be enabled");
auto did_rename_it = file_ops.find("didRename");
assertTrue(did_rename_it != file_ops.end(), "fileOperations should include didRename");
assertTrue(did_rename_it->second.Is<protocol::boolean>() && did_rename_it->second.Get<protocol::boolean>(),
"fileOperations.didRename should be enabled");
}
assertFalse(capabilities.contains("hoverProvider"), "Initialize should not advertise hoverProvider");
assertFalse(capabilities.contains("referencesProvider"), "Initialize should not advertise referencesProvider");
assertFalse(capabilities.contains("renameProvider"), "Initialize should not advertise renameProvider");
assertFalse(capabilities.contains("documentSymbolProvider"), "Initialize should not advertise documentSymbolProvider");
assertFalse(capabilities.contains("workspaceSymbolProvider"), "Initialize should not advertise workspaceSymbolProvider");
assertFalse(capabilities.contains("workspace"), "Initialize should not advertise workspace capabilities");
env.scheduler.WaitAll();
auto indexed = env.hub.symbols().QueryIndexedSymbols(protocol::SymbolKind::Module);