chore(lsp): remove capabilities sanitization (#17814)

* feat(lsp)!: remove capabilities sanitization

Users must now access client.server_capabilities which matches the same
structure as the protocol.

https://microsoft.github.io/language-server-protocol/specification

client.resolved_capabilities is no longer used to gate capabilities, and
will be removed in a future release.

BREAKING CHANGE


Co-authored-by: Mathias Fussenegger <f.mathias@zignar.net>

runtime/doc/lsp.txt

@@ -653,9 +653,6 @@ client()                                                      *vim.lsp.client*
                     user to |vim.lsp.start_client()|.
                   • {server_capabilities} (table): Response from the server
                     sent on `initialize` describing the server's capabilities.
-                  • {resolved_capabilities} (table): Normalized table of
-                    capabilities that we have detected based on the initialize
-                    response from the server in `server_capabilities`.
 
 client_is_stopped({client_id})                   *vim.lsp.client_is_stopped()*
                 Checks whether a client is stopped.
@@ -1875,8 +1872,8 @@ request({method}, {params}, {callback}, {notify_reply_callback})
                     {params}                 (table) Parameters for the
                                              invoked LSP method
                     {callback}               (function) Callback to invoke
-                    {notify_reply_callback}  (function) Callback to invoke as
-                                             soon as a request is no longer
+                    {notify_reply_callback}  (function|nil) Callback to invoke
+                                             as soon as a request is no longer
                                              pending
 
                 Return: ~

runtime/lua/vim/lsp.lua

@@ -31,28 +31,28 @@ local lsp = {
   rpc_response_error = lsp_rpc.rpc_response_error;
 }
 
--- maps request name to the required resolved_capability in the client.
+-- maps request name to the required server_capability in the client.
 lsp._request_name_to_capability = {
-  ['textDocument/hover'] = 'hover';
-  ['textDocument/signatureHelp'] = 'signature_help';
-  ['textDocument/definition'] = 'goto_definition';
-  ['textDocument/implementation'] = 'implementation';
-  ['textDocument/declaration'] = 'declaration';
-  ['textDocument/typeDefinition'] = 'type_definition';
-  ['textDocument/documentSymbol'] = 'document_symbol';
-  ['textDocument/prepareCallHierarchy'] = 'call_hierarchy';
-  ['textDocument/rename'] = 'rename';
-  ['textDocument/prepareRename'] = 'rename';
-  ['textDocument/codeAction'] = 'code_action';
-  ['textDocument/codeLens'] = 'code_lens';
-  ['codeLens/resolve'] = 'code_lens_resolve';
-  ['workspace/executeCommand'] = 'execute_command';
-  ['workspace/symbol'] = 'workspace_symbol';
-  ['textDocument/references'] = 'find_references';
-  ['textDocument/rangeFormatting'] = 'document_range_formatting';
-  ['textDocument/formatting'] = 'document_formatting';
-  ['textDocument/completion'] = 'completion';
-  ['textDocument/documentHighlight'] = 'document_highlight';
+  ['textDocument/hover'] = { 'hoverProvider' };
+  ['textDocument/signatureHelp'] = { 'signatureHelpProvider' };
+  ['textDocument/definition'] = { 'definitionProvider' };
+  ['textDocument/implementation'] = { 'implementationProvider' };
+  ['textDocument/declaration'] = { 'declarationProvider' };
+  ['textDocument/typeDefinition'] = { 'typeDefinitionProvider' };
+  ['textDocument/documentSymbol'] = { 'documentSymbolProvider' };
+  ['textDocument/prepareCallHierarchy'] = { 'callHierarchyProvider' };
+  ['textDocument/rename'] = { 'renameProvider' };
+  ['textDocument/prepareRename'] = { 'renameProvider', 'prepareProvider'} ;
+  ['textDocument/codeAction'] = { 'codeActionProvider' };
+  ['textDocument/codeLens'] = { 'codeLensProvider' };
+  ['codeLens/resolve'] = { 'codeLensProvider', 'resolveProvider' };
+  ['workspace/executeCommand'] = { 'executeCommandProvider' };
+  ['workspace/symbol'] = { 'workspaceSymbolProvider' };
+  ['textDocument/references'] = { 'referencesProvider' };
+  ['textDocument/rangeFormatting'] = { 'documentRangeFormattingProvider' };
+  ['textDocument/formatting'] = { 'documentFormattingProvider' };
+  ['textDocument/completion'] = { 'completionProvider' };
+  ['textDocument/documentHighlight'] = { 'documentHighlightProvider' };
 }
 
 -- TODO improve handling of scratch buffers with LSP attached.
@@ -328,7 +328,7 @@ do
   function changetracking.init(client, bufnr)
     local use_incremental_sync = (
       if_nil(client.config.flags.allow_incremental_sync, true)
-      and client.resolved_capabilities.text_document_did_change == protocol.TextDocumentSyncKind.Incremental
+      and vim.tbl_get(client.server_capabilities, "textDocumentSync", "change") == protocol.TextDocumentSyncKind.Incremental
     )
     local state = state_by_client[client.id]
     if not state then
@@ -447,7 +447,7 @@ do
     end)
     local uri = vim.uri_from_bufnr(bufnr)
     return function(client)
-      if client.resolved_capabilities.text_document_did_change == protocol.TextDocumentSyncKind.None then
+      if vim.tbl_get(client.server_capabilities, "textDocumentSync", "change")  == protocol.TextDocumentSyncKind.None then
         return
       end
       local state = state_by_client[client.id]
@@ -526,7 +526,7 @@ end
 ---@param client Client object
 local function text_document_did_open_handler(bufnr, client)
   changetracking.init(client, bufnr)
-  if not client.resolved_capabilities.text_document_open_close then
+  if not vim.tbl_get(client.server_capabilities, "textDocumentSync", "openClose") then
     return
   end
   if not vim.api.nvim_buf_is_loaded(bufnr) then
@@ -632,10 +632,6 @@ end
 ---
 ---  - {server_capabilities} (table): Response from the server sent on
 ---    `initialize` describing the server's capabilities.
----
----  - {resolved_capabilities} (table): Normalized table of
----    capabilities that we have detected based on the initialize
----    response from the server in `server_capabilities`.
 function lsp.client()
   error()
 end
@@ -884,6 +880,7 @@ function lsp.start_client(config)
     messages = { name = name, messages = {}, progress = {}, status = {} };
   }
 
+
   -- Store the uninitialized_clients for cleanup in case we exit before initialize finishes.
   uninitialized_clients[client_id] = client;
 
@@ -960,27 +957,48 @@ function lsp.start_client(config)
       client.workspace_folders = workspace_folders
       -- TODO(mjlbach): Backwards compatibility, to be removed in 0.7
       client.workspaceFolders = client.workspace_folders
-      client.server_capabilities = assert(result.capabilities, "initialize result doesn't contain capabilities")
+
       -- These are the cleaned up capabilities we use for dynamically deciding
       -- when to send certain events to clients.
-      client.resolved_capabilities = protocol.resolve_capabilities(client.server_capabilities)
+      client.server_capabilities = assert(result.capabilities, "initialize result doesn't contain capabilities")
+      client.server_capabilities = protocol.resolve_capabilities(client.server_capabilities)
+
+      -- Deprecation wrapper: this will be removed in 0.8
+      local mt = {}
+      mt.__index = function(table, key)
+        if key == 'resolved_capabilities' then
+          vim.notify_once("[LSP] Accessing client.resolved_capabilities is deprecated, " ..
+          "update your plugins or configuration to access client.server_capabilities instead." ..
+          "The new key/value pairs in server_capabilities directly match those " ..
+          "defined in the language server protocol", vim.log.levels.WARN)
+          table[key] = protocol._resolve_capabilities_compat(client.server_capabilities)
+          return table[key]
+        else
+          return table[key]
+        end
+      end
+      setmetatable(client, mt)
+
       client.supports_method = function(method)
         local required_capability = lsp._request_name_to_capability[method]
         -- if we don't know about the method, assume that the client supports it.
         if not required_capability then
           return true
         end
-
-        return client.resolved_capabilities[required_capability]
+        if vim.tbl_get(client.server_capabilities, unpack(required_capability)) then
+          return true
+        else
+          return false
+        end
       end
+
       if config.on_init then
         local status, err = pcall(config.on_init, client, result)
         if not status then
           pcall(handlers.on_error, lsp.client_errors.ON_INIT_CALLBACK_ERROR, err)
         end
       end
-      local _ = log.debug() and log.debug(log_prefix, "server_capabilities", client.server_capabilities)
-      local _ = log.info() and log.info(log_prefix, "initialized", { resolved_capabilities = client.resolved_capabilities })
+      local _ = log.info() and log.info(log_prefix, "server_capabilities", { server_capabilities = client.server_capabilities })
 
       -- Only assign after initialized.
       active_clients[client_id] = client
@@ -1191,9 +1209,9 @@ function lsp._text_document_did_save_handler(bufnr)
   local uri = vim.uri_from_bufnr(bufnr)
   local text = once(buf_get_full_text)
   for_each_buffer_client(bufnr, function(client, _client_id)
-    if client.resolved_capabilities.text_document_save then
+    if vim.tbl_get(client.server_capabilities, "textDocumentSync", "save") then
       local included_text
-      if client.resolved_capabilities.text_document_save_include_text then
+      if vim.tbl_get(client.server_capabilities, "textDocumentSync", "save", "includeText") then
         included_text = text(bufnr)
       end
       client.notify('textDocument/didSave', {
@@ -1246,7 +1264,7 @@ function lsp.buf_attach_client(bufnr, client_id)
         local params = { textDocument = { uri = uri; } }
         for_each_buffer_client(bufnr, function(client, _)
           changetracking.reset_buf(client, bufnr)
-          if client.resolved_capabilities.text_document_open_close then
+          if vim.tbl_get(client.server_capabilities, "textDocumentSync", "openClose") then
             client.notify('textDocument/didClose', params)
           end
           text_document_did_open_handler(bufnr, client)
@@ -1256,7 +1274,7 @@ function lsp.buf_attach_client(bufnr, client_id)
         local params = { textDocument = { uri = uri; } }
         for_each_buffer_client(bufnr, function(client, _)
           changetracking.reset_buf(client, bufnr)
-          if client.resolved_capabilities.text_document_open_close then
+          if vim.tbl_get(client.server_capabilities, "textDocumentSync", "openClose") then
             client.notify('textDocument/didClose', params)
           end
         end)
@@ -1306,7 +1324,7 @@ function lsp.buf_detach_client(bufnr, client_id)
 
   changetracking.reset_buf(client, bufnr)
 
-  if client.resolved_capabilities.text_document_open_close then
+  if vim.tbl_get(client.server_capabilities, "textDocumentSync", "openClose") then
     local uri = vim.uri_from_bufnr(bufnr)
     local params = { textDocument = { uri = uri; } }
     client.notify('textDocument/didClose', params)

runtime/lua/vim/lsp/buf.lua

@@ -224,7 +224,7 @@ function M.formatting_seq_sync(options, timeout_ms, order)
 
   -- loop through the clients and make synchronous formatting requests
   for _, client in pairs(clients) do
-    if client.resolved_capabilities.document_formatting then
+    if vim.tbl_get(client.server_capabilities, "documentFormattingProvider") then
       local params = util.make_formatting_params(options)
       local result, err = client.request_sync("textDocument/formatting", params, timeout_ms, vim.api.nvim_get_current_buf())
       if result and result.result then
@@ -545,8 +545,7 @@ local function on_code_action_results(results, ctx, options)
     local action = action_tuple[2]
     if not action.edit
         and client
-        and type(client.resolved_capabilities.code_action) == 'table'
-        and client.resolved_capabilities.code_action.resolveProvider then
+        and vim.tbl_get(client.server_capabilities, "codeActionProvider", "resolveProvider") then
 
       client.request('codeAction/resolve', action, function(err, resolved_action)
         if err then

runtime/lua/vim/lsp/handlers.lua

@@ -379,7 +379,7 @@ function M.signature_help(_, result, ctx, config)
     return
   end
   local client = vim.lsp.get_client_by_id(ctx.client_id)
-  local triggers = client.resolved_capabilities.signature_help_trigger_characters
+  local triggers = vim.tbl_get(client.server_capabilities, "signatureHelpProvider", "triggerCharacters")
   local ft = api.nvim_buf_get_option(ctx.bufnr, 'filetype')
   local lines, hl = util.convert_signature_help_to_markdown_lines(result, ft, triggers)
   lines = util.trim_empty_lines(lines)

runtime/lua/vim/lsp/protocol.lua

@@ -1,7 +1,5 @@
 -- Protocol for the Microsoft Language Server Protocol (mslsp)
 
-local if_nil = vim.F.if_nil
-
 local protocol = {}
 
 --[=[
@@ -777,10 +775,50 @@ function protocol.make_client_capabilities()
   }
 end
 
+local if_nil = vim.F.if_nil
 --- Creates a normalized object describing LSP server capabilities.
 ---@param server_capabilities table Table of capabilities supported by the server
 ---@return table Normalized table of capabilities
 function protocol.resolve_capabilities(server_capabilities)
+  local TextDocumentSyncKind = protocol.TextDocumentSyncKind
+  local textDocumentSync = server_capabilities.textDocumentSync
+  if textDocumentSync == nil then
+    -- Defaults if omitted.
+    server_capabilities.textDocumentSync = {
+      openClose = false,
+      change = TextDocumentSyncKind.None,
+      willSave = false,
+      willSaveWaitUntil = false,
+      save = {
+        includeText = false,
+      }
+    }
+  elseif type(textDocumentSync) == 'number' then
+    -- Backwards compatibility
+    if not TextDocumentSyncKind[textDocumentSync] then
+      return nil, "Invalid server TextDocumentSyncKind for textDocumentSync"
+    end
+    server_capabilities.textDocumentSync = {
+      openClose = true,
+      change = textDocumentSync,
+      willSave = false,
+      willSaveWaitUntil = false,
+      save = {
+        includeText = false,
+      }
+    }
+  elseif type(textDocumentSync) ~= 'table' then
+    return nil, string.format("Invalid type for textDocumentSync: %q", type(textDocumentSync))
+  end
+  return server_capabilities
+end
+
+---@private
+--- Creates a normalized object describing LSP server capabilities.
+-- @deprecated access resolved_capabilities instead
+---@param server_capabilities table Table of capabilities supported by the server
+---@return table Normalized table of capabilities
+function protocol._resolve_capabilities_compat(server_capabilities)
   local general_properties = {}
   local text_document_sync_properties
   do
@@ -931,12 +969,14 @@ function protocol.resolve_capabilities(server_capabilities)
     error("The server sent invalid signatureHelpProvider")
   end
 
-  return vim.tbl_extend("error"
+  local capabilities = vim.tbl_extend("error"
       , text_document_sync_properties
       , signature_help_properties
       , workspace_properties
       , general_properties
       )
+
+  return capabilities
 end
 
 return protocol

runtime/lua/vim/lsp/rpc.lua

@@ -385,7 +385,7 @@ local function start(cmd, cmd_args, dispatchers, extra_spawn_params)
   ---@param method (string) The invoked LSP method
   ---@param params (table) Parameters for the invoked LSP method
   ---@param callback (function) Callback to invoke
-  ---@param notify_reply_callback (function) Callback to invoke as soon as a request is no longer pending
+  ---@param notify_reply_callback (function|nil) Callback to invoke as soon as a request is no longer pending
   ---@returns (bool, number) `(true, message_id)` if request could be sent, `false` if not
   local function request(method, params, callback, notify_reply_callback)
     validate {

test/functional/fixtures/fake-lsp-server.lua

@@ -100,8 +100,12 @@ local tests = {}
 
 function tests.basic_init()
   skeleton {
-    on_init = function(_params)
-      return { capabilities = {} }
+    on_init = function(_)
+      return {
+        capabilities = {
+          textDocumentSync = protocol.TextDocumentSyncKind.None;
+        }
+      }
     end;
     body = function()
       notify('test')
@@ -132,8 +136,11 @@ function tests.prepare_rename_nil()
   skeleton {
     on_init = function()
       return { capabilities = {
-        renameProvider = true,
-      } }
+        renameProvider = {
+            prepareProvider = true
+          }
+        }
+      }
     end;
     body = function()
       notify('start')
@@ -149,8 +156,11 @@ function tests.prepare_rename_placeholder()
   skeleton {
     on_init = function()
       return { capabilities = {
-        renameProvider = true,
-      } }
+        renameProvider = {
+            prepareProvider = true
+          }
+        }
+      }
     end;
     body = function()
       notify('start')
@@ -170,8 +180,11 @@ function tests.prepare_rename_range()
   skeleton {
     on_init = function()
       return { capabilities = {
-        renameProvider = true,
-      } }
+        renameProvider = {
+            prepareProvider = true
+          }
+        }
+      }
     end;
     body = function()
       notify('start')
@@ -193,9 +206,13 @@ end
 function tests.prepare_rename_error()
   skeleton {
     on_init = function()
-      return { capabilities = {
-        renameProvider = true,
-      } }
+      return {
+        capabilities = {
+          renameProvider = {
+            prepareProvider = true
+          },
+        }
+      }
     end;
     body = function()
       notify('start')
@@ -219,6 +236,7 @@ function tests.basic_check_capabilities()
       return {
         capabilities = {
           textDocumentSync = protocol.TextDocumentSyncKind.Full;
+          codeLensProvider = false
         }
       }
     end;
@@ -237,6 +255,7 @@ function tests.capabilities_for_client_supports_method()
           textDocumentSync = protocol.TextDocumentSyncKind.Full;
           completionProvider = true;
           hoverProvider = true;
+          renameProvider = false;
           definitionProvider = false;
           referencesProvider = false;
           codeLensProvider = { resolveProvider = true; };
@@ -544,7 +563,15 @@ function tests.basic_check_buffer_open_and_change_incremental()
       assert_eq(params.capabilities, expected_capabilities)
       return {
         capabilities = {
-          textDocumentSync = protocol.TextDocumentSyncKind.Incremental;
+          textDocumentSync = {
+            openClose = true,
+            change = protocol.TextDocumentSyncKind.Incremental,
+            willSave = true,
+            willSaveWaitUntil = true,
+            save = {
+              includeText = true,
+            }
+          }
         }
       }
     end;

test/functional/plugin/lsp_spec.lua

@@ -289,7 +289,7 @@ describe('LSP', function()
       test_rpc_server {
         test_name = "basic_init";
         on_init = function(client)
-          eq(0, client.resolved_capabilities().text_document_did_change)
+          eq(0, client.server_capabilities().textDocumentSync.change)
           client.request('shutdown')
           client.notify('exit')
           client.stop()
@@ -407,10 +407,9 @@ describe('LSP', function()
         on_init = function(client)
           client.stop()
           local full_kind = exec_lua("return require'vim.lsp.protocol'.TextDocumentSyncKind.Full")
-          eq(full_kind, client.resolved_capabilities().text_document_did_change)
-          eq(true, client.resolved_capabilities().text_document_save)
-          eq(false, client.resolved_capabilities().code_lens)
-          eq(false, client.resolved_capabilities().code_lens_resolve)
+          eq(full_kind, client.server_capabilities().textDocumentSync.change)
+          eq({includeText = false}, client.server_capabilities().textDocumentSync.save)
+          eq(false, client.server_capabilities().codeLensProvider)
         end;
         on_exit = function(code, signal)
           eq(0, code, "exit code", fake_lsp_logfile)
@@ -430,14 +429,19 @@ describe('LSP', function()
         test_name = "capabilities_for_client_supports_method";
         on_init = function(client)
           client.stop()
-          local full_kind = exec_lua("return require'vim.lsp.protocol'.TextDocumentSyncKind.Full")
-          eq(full_kind, client.resolved_capabilities().text_document_did_change)
-          eq(true, client.resolved_capabilities().completion)
-          eq(true, client.resolved_capabilities().hover)
-          eq(false, client.resolved_capabilities().goto_definition)
-          eq(false, client.resolved_capabilities().rename)
-          eq(true, client.resolved_capabilities().code_lens)
-          eq(true, client.resolved_capabilities().code_lens_resolve)
+          local expected_sync_capabilities = {
+            change = 1,
+            openClose = true,
+            save = { includeText = false },
+            willSave = false,
+            willSaveWaitUntil = false,
+          }
+          eq(expected_sync_capabilities, client.server_capabilities().textDocumentSync)
+          eq(true, client.server_capabilities().completionProvider)
+          eq(true, client.server_capabilities().hoverProvider)
+          eq(false, client.server_capabilities().definitionProvider)
+          eq(false, client.server_capabilities().renameProvider)
+          eq(true, client.server_capabilities().codeLensProvider.resolveProvider)
 
           -- known methods for resolved capabilities
           eq(true, client.supports_method("textDocument/hover"))
@@ -720,8 +724,8 @@ describe('LSP', function()
         on_init = function(_client)
           client = _client
           local full_kind = exec_lua("return require'vim.lsp.protocol'.TextDocumentSyncKind.Full")
-          eq(full_kind, client.resolved_capabilities().text_document_did_change)
-          eq(true, client.resolved_capabilities().text_document_open_close)
+          eq(full_kind, client.server_capabilities().textDocumentSync.change)
+          eq(true, client.server_capabilities().textDocumentSync.openClose)
           client.notify('finish')
         end;
         on_exit = function(code, signal)
@@ -761,8 +765,8 @@ describe('LSP', function()
         on_init = function(_client)
           client = _client
           local full_kind = exec_lua("return require'vim.lsp.protocol'.TextDocumentSyncKind.Full")
-          eq(full_kind, client.resolved_capabilities().text_document_did_change)
-          eq(true, client.resolved_capabilities().text_document_open_close)
+          eq(full_kind, client.server_capabilities().textDocumentSync.change)
+          eq(true, client.server_capabilities().textDocumentSync.openClose)
           exec_lua [[
             assert(not lsp.buf_attach_client(BUFFER, TEST_RPC_CLIENT_ID), "Shouldn't attach twice")
           ]]
@@ -804,8 +808,8 @@ describe('LSP', function()
         on_init = function(_client)
           client = _client
           local full_kind = exec_lua("return require'vim.lsp.protocol'.TextDocumentSyncKind.Full")
-          eq(full_kind, client.resolved_capabilities().text_document_did_change)
-          eq(true, client.resolved_capabilities().text_document_open_close)
+          eq(full_kind, client.server_capabilities().textDocumentSync.change)
+          eq(true, client.server_capabilities().textDocumentSync.openClose)
           exec_lua [[
             assert(lsp.buf_attach_client(BUFFER, TEST_RPC_CLIENT_ID))
           ]]
@@ -847,8 +851,8 @@ describe('LSP', function()
         on_init = function(_client)
           client = _client
           local full_kind = exec_lua("return require'vim.lsp.protocol'.TextDocumentSyncKind.Full")
-          eq(full_kind, client.resolved_capabilities().text_document_did_change)
-          eq(true, client.resolved_capabilities().text_document_open_close)
+          eq(full_kind, client.server_capabilities().textDocumentSync.change)
+          eq(true, client.server_capabilities().textDocumentSync.openClose)
           exec_lua [[
             assert(lsp.buf_attach_client(BUFFER, TEST_RPC_CLIENT_ID))
           ]]
@@ -896,8 +900,8 @@ describe('LSP', function()
         on_init = function(_client)
           client = _client
           local full_kind = exec_lua("return require'vim.lsp.protocol'.TextDocumentSyncKind.Full")
-          eq(full_kind, client.resolved_capabilities().text_document_did_change)
-          eq(true, client.resolved_capabilities().text_document_open_close)
+          eq(full_kind, client.server_capabilities().textDocumentSync.change)
+          eq(true, client.server_capabilities().textDocumentSync.openClose)
           exec_lua [[
             assert(lsp.buf_attach_client(BUFFER, TEST_RPC_CLIENT_ID))
           ]]
@@ -947,8 +951,8 @@ describe('LSP', function()
         on_init = function(_client)
           client = _client
           local sync_kind = exec_lua("return require'vim.lsp.protocol'.TextDocumentSyncKind.Incremental")
-          eq(sync_kind, client.resolved_capabilities().text_document_did_change)
-          eq(true, client.resolved_capabilities().text_document_open_close)
+          eq(sync_kind, client.server_capabilities().textDocumentSync.change)
+          eq(true, client.server_capabilities().textDocumentSync.openClose)
           exec_lua [[
             assert(lsp.buf_attach_client(BUFFER, TEST_RPC_CLIENT_ID))
           ]]
@@ -998,8 +1002,8 @@ describe('LSP', function()
         on_init = function(_client)
           client = _client
           local sync_kind = exec_lua("return require'vim.lsp.protocol'.TextDocumentSyncKind.Incremental")
-          eq(sync_kind, client.resolved_capabilities().text_document_did_change)
-          eq(true, client.resolved_capabilities().text_document_open_close)
+          eq(sync_kind, client.server_capabilities().textDocumentSync.change)
+          eq(true, client.server_capabilities().textDocumentSync.openClose)
           exec_lua [[
             assert(lsp.buf_attach_client(BUFFER, TEST_RPC_CLIENT_ID))
           ]]
@@ -1047,8 +1051,8 @@ describe('LSP', function()
         on_init = function(_client)
           client = _client
           local sync_kind = exec_lua("return require'vim.lsp.protocol'.TextDocumentSyncKind.Incremental")
-          eq(sync_kind, client.resolved_capabilities().text_document_did_change)
-          eq(true, client.resolved_capabilities().text_document_open_close)
+          eq(sync_kind, client.server_capabilities().textDocumentSync.change)
+          eq(true, client.server_capabilities().textDocumentSync.openClose)
           exec_lua [[
             assert(lsp.buf_attach_client(BUFFER, TEST_RPC_CLIENT_ID))
           ]]
@@ -1091,8 +1095,8 @@ describe('LSP', function()
         on_init = function(_client)
           client = _client
           local sync_kind = exec_lua("return require'vim.lsp.protocol'.TextDocumentSyncKind.Full")
-          eq(sync_kind, client.resolved_capabilities().text_document_did_change)
-          eq(true, client.resolved_capabilities().text_document_open_close)
+          eq(sync_kind, client.server_capabilities().textDocumentSync.change)
+          eq(true, client.server_capabilities().textDocumentSync.openClose)
           exec_lua [[
             assert(lsp.buf_attach_client(BUFFER, TEST_RPC_CLIENT_ID))
           ]]
@@ -1142,8 +1146,8 @@ describe('LSP', function()
         on_init = function(_client)
           client = _client
           local sync_kind = exec_lua("return require'vim.lsp.protocol'.TextDocumentSyncKind.Full")
-          eq(sync_kind, client.resolved_capabilities().text_document_did_change)
-          eq(true, client.resolved_capabilities().text_document_open_close)
+          eq(sync_kind, client.server_capabilities().textDocumentSync.change)
+          eq(true, client.server_capabilities().textDocumentSync.openClose)
           exec_lua [[
             assert(lsp.buf_attach_client(BUFFER, TEST_RPC_CLIENT_ID))
           ]]
@@ -2583,7 +2587,7 @@ describe('LSP', function()
         test_name = test.name;
         on_init = function(_client)
           client = _client
-          eq(true, client.resolved_capabilities().rename)
+          eq(true, client.server_capabilities().renameProvider.prepareProvider)
         end;
         on_setup = function()
           exec_lua([=[