Merge remote-tracking branch 'upstream/master' into floattitlefloattitle

1 files changed, 260 insertions, 294 deletions

diff --git a/runtime/doc/lsp.txt b/runtime/doc/lsp.txt
index 7fc0daa0ca..139f4c6bc5 100644
--- a/runtime/doc/lsp.txt
+++ b/runtime/doc/lsp.txt
@@ -40,7 +40,7 @@ Follow these steps to get LSP features:
       root_dir = vim.fs.dirname(vim.fs.find({'setup.py', 'pyproject.toml'}, { upward = true })[1]),
     })
 <
-     See |vim.lsp.start| for details.
+     See |vim.lsp.start()| for details.
 
   3. Configure keymaps and autocmds to utilize LSP features.
      See |lsp-config|.
@@ -48,19 +48,19 @@ Follow these steps to get LSP features:
                                                         *lsp-config*
 
 Starting a LSP client will automatically report diagnostics via
-|vim.diagnostic|. Read |vim.diagnostic.config| to learn how to customize the
+|vim.diagnostic|. Read |vim.diagnostic.config()| to learn how to customize the
 display.
 
 It also sets some buffer options if the options are otherwise empty and if the
 language server supports the functionality.
 
-- |omnifunc| is set to |vim.lsp.omnifunc|. This allows to trigger completion
-  using |i_CTRL-X_CTRL-o|
-- |tagfunc| is set to |vim.lsp.tagfunc|. This enables features like
+- 'omnifunc' is set to |vim.lsp.omnifunc()|. This allows to trigger completion
+  using |i_CTRL-X_CTRL-O|
+- 'tagfunc' is set to |vim.lsp.tagfunc()|. This enables features like
   go-to-definition, |:tjump|, and keymaps like |CTRL-]|, |CTRL-W_]|,
   |CTRL-W_}| to utilize the language server.
-- |formatexpr| is set to |vim.lsp.formatexpr| if both |formatprg| and
-  |formatexpr| are empty. This allows to format lines via |gq| if the language
+- 'formatexpr' is set to |vim.lsp.formatexpr()| if both 'formatprg' and
+  'formatexpr' are empty. This allows to format lines via |gq| if the language
   server supports it.
 
 To use other LSP features like hover, rename, etc. you can setup some
@@ -126,13 +126,14 @@ FAQ                                                     *lsp-faq*
      "after/ftplugin/python.vim".
 
 - Q: How do I run a request synchronously (e.g. for formatting on file save)?
-  A: Use the `_sync` variant of the function provided by |lsp-buf|, if it
-     exists.
+  A: Check if the function has an `async` parameter and set the value to
+  false.
 
      E.g. code formatting: >
 
      " Auto-format *.rs (rust) files prior to saving them
-     autocmd BufWritePre *.rs lua vim.lsp.buf.formatting_sync(nil, 1000)
+     " (async = false is the default for format)
+     autocmd BufWritePre *.rs lua vim.lsp.buf.format({ async = false })
 
 <
                                                            *lsp-vs-treesitter*
@@ -189,6 +190,7 @@ specification. These LSP requests/notifications are defined by default:
     textDocument/typeDefinition*
     window/logMessage
     window/showMessage
+    window/showDocument
     window/showMessageRequest
     workspace/applyEdit
     workspace/symbol
@@ -244,7 +246,7 @@ For |lsp-request|, each |lsp-handler| has this signature: >
         Where `err` must be shaped like an RPC error:
             `{ code, message, data? }`
 
-        You can use |vim.lsp.rpc_response_error()| to create this object.
+        You can use |vim.lsp.rpc.rpc_response_error()| to create this object.
 
 For |lsp-notification|, each |lsp-handler| has this signature: >
 
@@ -337,8 +339,8 @@ To configure the behavior of a builtin |lsp-handler|, the convenient method
     }
 <
   Some handlers do not have an explicitly named handler function (such as
-  |on_publish_diagnostics()|). To override these, first create a reference
-  to the existing handler: >
+  ||vim.lsp.diagnostic.on_publish_diagnostics()|). To override these, first
+  create a reference to the existing handler: >
 
     local on_references = vim.lsp.handlers["textDocument/references"]
     vim.lsp.handlers["textDocument/references"] = vim.lsp.with(
@@ -359,7 +361,7 @@ Handlers can be set by:
 
     vim.lsp.handlers["textDocument/definition"] = my_custom_default_definition
 <
-- The {handlers} parameter for |vim.lsp.start_client|.
+- The {handlers} parameter for |vim.lsp.start_client()|.
     This will set the |lsp-handler| as the default handler for this server.
 
     For example: >
@@ -468,7 +470,7 @@ LspCodeLens
     |nvim_buf_set_extmark()|.
 
 LspCodeLensSeparator                                 *hl-LspCodeLensSeparator*
-    Used to color the separator between two or more code lens.
+    Used to color the separator between two or more code lenses.
 
                                                      *lsp-highlight-signature*
 
@@ -513,7 +515,7 @@ callback in the "data" table. Example: >
       end,
     })
 <
-In addition, the following |User| |autocommands| are provided:
+Also the following |User| |autocommand|s are provided:
 
 LspProgressUpdate                                          *LspProgressUpdate*
     Upon receipt of a progress notification from the server. See
@@ -538,8 +540,8 @@ buf_attach_client({bufnr}, {client_id})          *vim.lsp.buf_attach_client()*
     Without calling this, the server won't be notified of changes to a buffer.
 
     Parameters: ~
-        {bufnr}      (number) Buffer handle, or 0 for current
-        {client_id}  (number) Client id
+      • {bufnr}      (number) Buffer handle, or 0 for current
+      • {client_id}  (number) Client id
 
 buf_detach_client({bufnr}, {client_id})          *vim.lsp.buf_detach_client()*
     Detaches client from the specified buffer. Note: While the server is
@@ -547,23 +549,23 @@ buf_detach_client({bufnr}, {client_id})          *vim.lsp.buf_detach_client()*
     send notifications should it ignore this notification.
 
     Parameters: ~
-        {bufnr}      (number) Buffer handle, or 0 for current
-        {client_id}  (number) Client id
+      • {bufnr}      (number) Buffer handle, or 0 for current
+      • {client_id}  (number) Client id
 
 buf_is_attached({bufnr}, {client_id})              *vim.lsp.buf_is_attached()*
     Checks if a buffer is attached for a particular client.
 
     Parameters: ~
-        {bufnr}      (number) Buffer handle, or 0 for current
-        {client_id}  (number) the client id
+      • {bufnr}      (number) Buffer handle, or 0 for current
+      • {client_id}  (number) the client id
 
 buf_notify({bufnr}, {method}, {params})                 *vim.lsp.buf_notify()*
     Send a notification to a server
 
     Parameters: ~
-        {bufnr}   [number] (optional): The number of the buffer
-        {method}  [string]: Name of the request method
-        {params}  [string]: Arguments to send to the server
+      • {bufnr}   [number] (optional): The number of the buffer
+      • {method}  [string]: Name of the request method
+      • {params}  [string]: Arguments to send to the server
 
     Return: ~
         true if any client returns true; false otherwise
@@ -575,10 +577,10 @@ buf_request_all({bufnr}, {method}, {params}, {callback})
     |vim.lsp.buf_request()| but the return result and callback are different.
 
     Parameters: ~
-        {bufnr}     (number) Buffer handle, or 0 for current.
-        {method}    (string) LSP method name
-        {params}    (optional, table) Parameters to send to the server
-        {callback}  (function) The callback to call when all requests are
+      • {bufnr}     (number) Buffer handle, or 0 for current.
+      • {method}    (string) LSP method name
+      • {params}    (optional, table) Parameters to send to the server
+      • {callback}  (function) The callback to call when all requests are
                     finished.
 
     Return: ~
@@ -594,10 +596,10 @@ buf_request_sync({bufnr}, {method}, {params}, {timeout_ms})
     result is different. Wait maximum of {timeout_ms} (default 1000) ms.
 
     Parameters: ~
-        {bufnr}       (number) Buffer handle, or 0 for current.
-        {method}      (string) LSP method name
-        {params}      (optional, table) Parameters to send to the server
-        {timeout_ms}  (optional, number, default=1000) Maximum time in
+      • {bufnr}       (number) Buffer handle, or 0 for current.
+      • {method}      (string) LSP method name
+      • {params}      (optional, table) Parameters to send to the server
+      • {timeout_ms}  (optional, number, default=1000) Maximum time in
                       milliseconds to wait for a result.
 
     Return: ~
@@ -665,7 +667,7 @@ client_is_stopped({client_id})                   *vim.lsp.client_is_stopped()*
     Checks whether a client is stopped.
 
     Parameters: ~
-        {client_id}  (Number)
+      • {client_id}  (Number)
 
     Return: ~
         true if client is stopped, false otherwise.
@@ -675,8 +677,8 @@ for_each_buffer_client({bufnr}, {fn})
     Invokes a function for each LSP client attached to a buffer.
 
     Parameters: ~
-        {bufnr}  (number) Buffer number
-        {fn}     (function) Function to run on each client attached to buffer
+      • {bufnr}  (number) Buffer number
+      • {fn}     (function) Function to run on each client attached to buffer
                  {bufnr}. The function takes the client, client ID, and buffer
                  number as arguments. Example: >
 
@@ -695,7 +697,7 @@ formatexpr({opts})                                      *vim.lsp.formatexpr()*
     'v:lua.vim.lsp.formatexpr(#{timeout_ms:250})')`.
 
     Parameters: ~
-        {opts}  (table) options for customizing the formatting expression
+      • {opts}  (table) options for customizing the formatting expression
                 which takes the following optional keys:
                 • timeout_ms (default 500ms). The timeout period for the
                   formatting request.
@@ -704,7 +706,7 @@ get_active_clients({filter})                    *vim.lsp.get_active_clients()*
     Get active clients.
 
     Parameters: ~
-        {filter}  (table|nil) A table with key-value pairs used to filter the
+      • {filter}  (table|nil) A table with key-value pairs used to filter the
                   returned clients. The available keys are:
                   • id (number): Only return clients with the given id
                   • bufnr (number): Only return clients attached to this
@@ -719,17 +721,17 @@ get_buffers_by_client_id({client_id})
     Returns list of buffers attached to client_id.
 
     Parameters: ~
-        {client_id}  (number) client id
+      • {client_id}  (number) client id
 
     Return: ~
-        list of buffer ids
+        (list) of buffer ids
 
 get_client_by_id({client_id})                     *vim.lsp.get_client_by_id()*
     Gets a client by id, or nil if the id is invalid. The returned client may
     not yet be fully initialized.
 
     Parameters: ~
-        {client_id}  (number) client id
+      • {client_id}  (number) client id
 
     Return: ~
         |vim.lsp.client| object, or nil
@@ -744,8 +746,8 @@ omnifunc({findstart}, {base})                             *vim.lsp.omnifunc()*
     Implements 'omnifunc' compatible LSP completion.
 
     Parameters: ~
-        {findstart}  0 or 1, decides behavior
-        {base}       If findstart=0, text to match against
+      • {findstart}  0 or 1, decides behavior
+      • {base}       If findstart=0, text to match against
 
     Return: ~
         (number) Decided by {findstart}:
@@ -767,7 +769,7 @@ set_log_level({level})                               *vim.lsp.set_log_level()*
     Use `lsp.log_levels` for reverse lookup.
 
     Parameters: ~
-        {level}  [number|string] the case insensitive level name or number
+      • {level}  [number|string] the case insensitive level name or number
 
     See also: ~
         |vim.lsp.log_levels|
@@ -787,7 +789,8 @@ start({config}, {opts})                                      *vim.lsp.start()*
     })
 <
 
-    See |lsp.start_client| for all available options. The most important are:
+    See |vim.lsp.start_client()| for all available options. The most important
+    are:
 
     `name` is an arbitrary name for the LSP client. It should be unique per
     language server.
@@ -797,9 +800,9 @@ start({config}, {opts})                                      *vim.lsp.start()*
     constructs like `~` are NOT expanded.
 
     `root_dir` path to the project root. By default this is used to decide if
-    an existing client should be re-used. The example above uses |vim.fs.find|
-    and |vim.fs.dirname| to detect the root by traversing the file system
-    upwards starting from the current directory until either a
+    an existing client should be re-used. The example above uses
+    |vim.fs.find()| and |vim.fs.dirname()| to detect the root by traversing
+    the file system upwards starting from the current directory until either a
     `pyproject.toml` or `setup.py` file is found.
 
     `workspace_folders` a list of { uri:string, name: string } tables. The
@@ -811,21 +814,23 @@ start({config}, {opts})                                      *vim.lsp.start()*
     the project folder.
 
     To ensure a language server is only started for languages it can handle,
-    make sure to call |vim.lsp.start| within a |FileType| autocmd. Either use
-    |:au|, |nvim_create_autocmd()| or put the call in a
+    make sure to call |vim.lsp.start()| within a |FileType| autocmd. Either
+    use |:au|, |nvim_create_autocmd()| or put the call in a
     `ftplugin/<filetype_name>.lua` (See |ftplugin-name|)
 
     Parameters: ~
-        {config}  (table) Same configuration as documented in
-                  |lsp.start_client()|
-        {opts}    nil|table Optional keyword arguments:
+      • {config}  (table) Same configuration as documented in
+                  |vim.lsp.start_client()|
+      • {opts}    nil|table Optional keyword arguments:
                   • reuse_client (fun(client: client, config: table): boolean)
                     Predicate used to decide if a client should be re-used.
                     Used on all running clients. The default implementation
                     re-uses a client if name and root_dir matches.
+                  • bufnr (number) Buffer handle to attach to if starting or
+                    re-using a client (0 for current).
 
     Return: ~
-        (number) client_id
+        (number|nil) client_id
 
 start_client({config})                                *vim.lsp.start_client()*
     Starts and initializes a client with the given configuration.
@@ -835,29 +840,37 @@ start_client({config})                                *vim.lsp.start_client()*
     The following parameters describe fields in the {config} table.
 
     Parameters: ~
-        {cmd}                (required, string or list treated like
-                             |jobstart()|) Base command that initiates the LSP
-                             client.
-        {cmd_cwd}            (string, default=|getcwd()|) Directory to launch
+      • {cmd}                (table|string|fun(dispatchers: table):table)
+                             command string or list treated like |jobstart()|.
+                             The command must launch the language server
+                             process. `cmd` can also be a function that
+                             creates an RPC client. The function receives a
+                             dispatchers table and must return a table with
+                             the functions `request`, `notify`, `is_closing`
+                             and `terminate` See |vim.lsp.rpc.request()| and
+                             |vim.lsp.rpc.notify()| For TCP there is a
+                             built-in rpc client factory:
+                             |vim.lsp.rpc.connect()|
+      • {cmd_cwd}            (string, default=|getcwd()|) Directory to launch
                              the `cmd` process. Not related to `root_dir`.
-        {cmd_env}            (table) Environment flags to pass to the LSP on
+      • {cmd_env}            (table) Environment flags to pass to the LSP on
                              spawn. Can be specified using keys like a map or
                              as a list with `k=v` pairs or both. Non-string values are coerced to
                              string. Example: >
 
      { "PRODUCTION=true"; "TEST=123"; PORT = 8080; HOST = "0.0.0.0"; }
 <
-        {detached}           (boolean, default true) Daemonize the server
+      • {detached}           (boolean, default true) Daemonize the server
                              process so that it runs in a separate process
                              group from Nvim. Nvim will shutdown the process
                              on exit, but if Nvim fails to exit cleanly this
                              could leave behind orphaned server processes.
-        {workspace_folders}  (table) List of workspace folders passed to the
+      • {workspace_folders}  (table) List of workspace folders passed to the
                              language server. For backwards compatibility
                              rootUri and rootPath will be derived from the
                              first workspace folder in this list. See
                              `workspaceFolders` in the LSP spec.
-        {capabilities}       Map overriding the default capabilities defined
+      • {capabilities}       Map overriding the default capabilities defined
                              by |vim.lsp.protocol.make_client_capabilities()|,
                              passed to the language server on initialization.
                              Hint: use make_client_capabilities() and modify
@@ -865,44 +878,44 @@ start_client({config})                                *vim.lsp.start_client()*
                              • Note: To send an empty dictionary use
                                `{[vim.type_idx]=vim.types.dictionary}`, else
                                it will be encoded as an array.
-        {handlers}           Map of language server method names to
+      • {handlers}           Map of language server method names to
                              |lsp-handler|
-        {settings}           Map with language server specific settings. These
+      • {settings}           Map with language server specific settings. These
                              are returned to the language server if requested
                              via `workspace/configuration`. Keys are
                              case-sensitive.
-        {commands}           (table) Table that maps string of clientside
+      • {commands}           (table) Table that maps string of clientside
                              commands to user-defined functions. Commands
                              passed to start_client take precedence over the
                              global command registry. Each key must be a
                              unique command name, and the value is a function
                              which is called if any LSP action (code action,
                              code lenses, ...) triggers the command.
-        {init_options}       Values to pass in the initialization request as
+      • {init_options}       Values to pass in the initialization request as
                              `initializationOptions`. See `initialize` in the
                              LSP spec.
-        {name}               (string, default=client-id) Name in log messages.
-        {get_language_id}    function(bufnr, filetype) -> language ID as
+      • {name}               (string, default=client-id) Name in log messages.
+      • {get_language_id}    function(bufnr, filetype) -> language ID as
                              string. Defaults to the filetype.
-        {offset_encoding}    (default="utf-16") One of "utf-8", "utf-16", or
+      • {offset_encoding}    (default="utf-16") One of "utf-8", "utf-16", or
                              "utf-32" which is the encoding that the LSP
                              server expects. Client does not verify this is
                              correct.
-        {on_error}           Callback with parameters (code, ...), invoked
+      • {on_error}           Callback with parameters (code, ...), invoked
                              when the client operation throws an error. `code`
                              is a number describing the error. Other arguments
                              may be passed depending on the error kind. See
-                             |vim.lsp.rpc.client_errors| for possible errors.
+                             `vim.lsp.rpc.client_errors` for possible errors.
                              Use `vim.lsp.rpc.client_errors[code]` to get
                              human-friendly name.
-        {before_init}        Callback with parameters (initialize_params,
+      • {before_init}        Callback with parameters (initialize_params,
                              config) invoked before the LSP "initialize"
                              phase, where `params` contains the parameters
                              being sent to the server and `config` is the
                              config that was passed to
                              |vim.lsp.start_client()|. You can use this to
                              modify parameters before they are sent.
-        {on_init}            Callback (client, initialize_result) invoked
+      • {on_init}            Callback (client, initialize_result) invoked
                              after LSP "initialize", where `result` is a table
                              of `capabilities` and anything else the server
                              may send. For example, clangd sends
@@ -915,19 +928,19 @@ start_client({config})                                *vim.lsp.start_client()*
                              make this assumption. A
                              `workspace/didChangeConfiguration` notification
                              should be sent to the server during on_init.
-        {on_exit}            Callback (code, signal, client_id) invoked on
+      • {on_exit}            Callback (code, signal, client_id) invoked on
                              client exit.
                              • code: exit code of the process
                              • signal: number describing the signal used to
                                terminate (if any)
                              • client_id: client handle
-        {on_attach}          Callback (client, bufnr) invoked when client
+      • {on_attach}          Callback (client, bufnr) invoked when client
                              attaches to a buffer.
-        {trace}              "off" | "messages" | "verbose" | nil passed
+      • {trace}              "off" | "messages" | "verbose" | nil passed
                              directly to the language server in the initialize
                              request. Invalid/empty values will default to
                              "off"
-        {flags}              A table with flags for the client. The current
+      • {flags}              A table with flags for the client. The current
                              (experimental) flags are:
                              • allow_incremental_sync (bool, default true):
                                Allow using incremental sync for buffer edits
@@ -937,11 +950,11 @@ start_client({config})                                *vim.lsp.start_client()*
                                debounce occurs if nil
                              • exit_timeout (number|boolean, default false):
                                Milliseconds to wait for server to exit cleanly
-                               after sending the 'shutdown' request before
+                               after sending the "shutdown" request before
                                sending kill -15. If set to false, nvim exits
-                               immediately after sending the 'shutdown'
+                               immediately after sending the "shutdown"
                                request to the server.
-        {root_dir}           (string) Directory where the LSP server will base
+      • {root_dir}           (string) Directory where the LSP server will base
                              its workspaceFolders, rootUri, and rootPath on
                              initialization.
 
@@ -964,8 +977,8 @@ stop_client({client_id}, {force})                      *vim.lsp.stop_client()*
     for this client, then force-shutdown is attempted.
 
     Parameters: ~
-        {client_id}  client id or |vim.lsp.client| object, or list thereof
-        {force}      (boolean) (optional) shutdown forcefully
+      • {client_id}  client id or |vim.lsp.client| object, or list thereof
+      • {force}      (boolean) (optional) shutdown forcefully
 
 tagfunc({...})                                             *vim.lsp.tagfunc()*
     Provides an interface between the built-in client and 'tagfunc'.
@@ -976,8 +989,8 @@ tagfunc({...})                                             *vim.lsp.tagfunc()*
     LSP servers, falls back to using built-in tags.
 
     Parameters: ~
-        {pattern}  Pattern used to find a workspace symbol
-        {flags}    See |tag-function|
+      • {pattern}  Pattern used to find a workspace symbol
+      • {flags}    See |tag-function|
 
     Return: ~
         A list of matching tags
@@ -986,8 +999,8 @@ with({handler}, {override_config})                            *vim.lsp.with()*
     Function to manage overriding defaults for LSP handlers.
 
     Parameters: ~
-        {handler}          (function) See |lsp-handler|
-        {override_config}  (table) Table containing the keys to override
+      • {handler}          (function) See |lsp-handler|
+      • {override_config}  (table) Table containing the keys to override
                            behavior of the {handler}
 
 
@@ -1006,7 +1019,7 @@ code_action({options})                             *vim.lsp.buf.code_action()*
     Selects a code action available at the current cursor position.
 
     Parameters: ~
-        {options}  (table|nil) Optional table which holds the following
+      • {options}  (table|nil) Optional table which holds the following
                    optional fields:
                    • context: (table|nil) Corresponds to `CodeActionContext` of the LSP specification:
                      • diagnostics (table|nil): LSP`Diagnostic[]` . Inferred from the current position if not provided.
@@ -1033,13 +1046,13 @@ completion({context})                               *vim.lsp.buf.completion()*
     called in Insert mode.
 
     Parameters: ~
-        {context}  (context support not yet implemented) Additional
+      • {context}  (context support not yet implemented) Additional
                    information about the context in which a completion was
                    triggered (how it was triggered, and by which trigger
                    character, if applicable)
 
     See also: ~
-        |vim.lsp.protocol.constants.CompletionTriggerKind|
+        vim.lsp.protocol.constants.CompletionTriggerKind
 
 declaration({options})                             *vim.lsp.buf.declaration()*
     Jumps to the declaration of the symbol under the cursor.
@@ -1048,7 +1061,7 @@ declaration({options})                             *vim.lsp.buf.declaration()*
         |vim.lsp.buf.definition()| instead.
 
     Parameters: ~
-        {options}  (table|nil) additional options
+      • {options}  (table|nil) additional options
                    • reuse_win: (boolean) Jump to existing window if buffer is
                      already open.
                    • on_list: (function) handler for list results. See
@@ -1058,7 +1071,7 @@ definition({options})                               *vim.lsp.buf.definition()*
     Jumps to the definition of the symbol under the cursor.
 
     Parameters: ~
-        {options}  (table|nil) additional options
+      • {options}  (table|nil) additional options
                    • reuse_win: (boolean) Jump to existing window if buffer is
                      already open.
                    • on_list: (function) handler for list results. See
@@ -1076,13 +1089,14 @@ document_highlight()                        *vim.lsp.buf.document_highlight()*
 
     Note: Usage of |vim.lsp.buf.document_highlight()| requires the following
     highlight groups to be defined or you won't be able to see the actual
-    highlights. |LspReferenceText| |LspReferenceRead| |LspReferenceWrite|
+    highlights. |hl-LspReferenceText| |hl-LspReferenceRead|
+    |hl-LspReferenceWrite|
 
 document_symbol({options})                     *vim.lsp.buf.document_symbol()*
     Lists all symbols in the current buffer in the quickfix window.
 
     Parameters: ~
-        {options}  (table|nil) additional options
+      • {options}  (table|nil) additional options
                    • on_list: (function) handler for list results. See
                      |lsp-on-list-handler|
 
@@ -1090,7 +1104,7 @@ execute_command({command_params})              *vim.lsp.buf.execute_command()*
     Executes an LSP server command.
 
     Parameters: ~
-        {command_params}  (table) A valid `ExecuteCommandParams` object
+      • {command_params}  (table) A valid `ExecuteCommandParams` object
 
     See also: ~
         https://microsoft.github.io/language-server-protocol/specifications/specification-current/#workspace_executeCommand
@@ -1100,7 +1114,7 @@ format({options})                                       *vim.lsp.buf.format()*
     server clients.
 
     Parameters: ~
-        {options}  table|nil Optional table which holds the following optional
+      • {options}  table|nil Optional table which holds the following optional
                    fields:
                    • formatting_options (table|nil): Can be used to specify
                      FormattingOptions. Some unspecified options will be
@@ -1128,59 +1142,11 @@ format({options})                                       *vim.lsp.buf.format()*
                      ID (client.id) matching this field.
                    • name (string|nil): Restrict formatting to the client with
                      name (client.name) matching this field.
-
-formatting({options})                               *vim.lsp.buf.formatting()*
-    Formats the current buffer.
-
-    Parameters: ~
-        {options}  (table|nil) Can be used to specify FormattingOptions. Some
-                   unspecified options will be automatically derived from the
-                   current Neovim options.
-
-    See also: ~
-        https://microsoft.github.io/language-server-protocol/specification#textDocument_formatting
-
-                                           *vim.lsp.buf.formatting_seq_sync()*
-formatting_seq_sync({options}, {timeout_ms}, {order})
-    Formats the current buffer by sequentially requesting formatting from
-    attached clients.
-
-    Useful when multiple clients with formatting capability are attached.
-
-    Since it's synchronous, can be used for running on save, to make sure
-    buffer is formatted prior to being saved. {timeout_ms} is passed on to the
-    |vim.lsp.client| `request_sync` method. Example: >
-
-     vim.api.nvim_command[[autocmd BufWritePre <buffer> lua vim.lsp.buf.formatting_seq_sync()]]
-<
-
-    Parameters: ~
-        {options}     (table|nil) `FormattingOptions` entries
-        {timeout_ms}  (number|nil) Request timeout
-        {order}       (table|nil) List of client names. Formatting is
-                      requested from clients in the following order: first all
-                      clients that are not in the `order` list, then the
-                      remaining clients in the order as they occur in the
-                      `order` list.
-
-                                               *vim.lsp.buf.formatting_sync()*
-formatting_sync({options}, {timeout_ms})
-    Performs |vim.lsp.buf.formatting()| synchronously.
-
-    Useful for running on save, to make sure buffer is formatted prior to
-    being saved. {timeout_ms} is passed on to |vim.lsp.buf_request_sync()|.
-    Example:
->
-
-    autocmd BufWritePre <buffer> lua vim.lsp.buf.formatting_sync()
-<
-
-    Parameters: ~
-        {options}     (table|nil) with valid `FormattingOptions` entries
-        {timeout_ms}  (number) Request timeout
-
-    See also: ~
-        |vim.lsp.buf.formatting_seq_sync|
+                   • range (table|nil) Range to format. Table must contain
+                     `start` and `end` keys with {row, col} tuples using (1,0)
+                     indexing. Defaults to current selection in visual mode
+                     Defaults to `nil` in other modes, formatting the full
+                     buffer
 
 hover()                                                  *vim.lsp.buf.hover()*
     Displays hover information about the symbol under the cursor in a floating
@@ -1191,14 +1157,14 @@ implementation({options})                       *vim.lsp.buf.implementation()*
     quickfix window.
 
     Parameters: ~
-        {options}  (table|nil) additional options
+      • {options}  (table|nil) additional options
                    • on_list: (function) handler for list results. See
                      |lsp-on-list-handler|
 
 incoming_calls()                                *vim.lsp.buf.incoming_calls()*
     Lists all the call sites of the symbol under the cursor in the |quickfix|
     window. If the symbol can resolve to multiple items, the user can pick one
-    in the |inputlist|.
+    in the |inputlist()|.
 
 list_workspace_folders()                *vim.lsp.buf.list_workspace_folders()*
     List workspace folders.
@@ -1206,41 +1172,15 @@ list_workspace_folders()                *vim.lsp.buf.list_workspace_folders()*
 outgoing_calls()                                *vim.lsp.buf.outgoing_calls()*
     Lists all the items that are called by the symbol under the cursor in the
     |quickfix| window. If the symbol can resolve to multiple items, the user
-    can pick one in the |inputlist|.
-
-                                             *vim.lsp.buf.range_code_action()*
-range_code_action({context}, {start_pos}, {end_pos})
-    Performs |vim.lsp.buf.code_action()| for a given range.
-
-    Parameters: ~
-        {context}    (table|nil) `CodeActionContext` of the LSP specification:
-                     • diagnostics: (table|nil) LSP`Diagnostic[]` . Inferred from the current position if not provided.
-                     • only: (table|nil) List of LSP `CodeActionKind`s used to
-                       filter the code actions. Most language servers support
-                       values like `refactor` or `quickfix`.
-        {start_pos}  ({number, number}, optional) mark-indexed position.
-                     Defaults to the start of the last visual selection.
-        {end_pos}    ({number, number}, optional) mark-indexed position.
-                     Defaults to the end of the last visual selection.
-
-                                              *vim.lsp.buf.range_formatting()*
-range_formatting({options}, {start_pos}, {end_pos})
-    Formats a given range.
-
-    Parameters: ~
-        {options}    Table with valid `FormattingOptions` entries.
-        {start_pos}  ({number, number}, optional) mark-indexed position.
-                     Defaults to the start of the last visual selection.
-        {end_pos}    ({number, number}, optional) mark-indexed position.
-                     Defaults to the end of the last visual selection.
+    can pick one in the |inputlist()|.
 
 references({context}, {options})                    *vim.lsp.buf.references()*
     Lists all the references to the symbol under the cursor in the quickfix
     window.
 
     Parameters: ~
-        {context}  (table) Context for the request
-        {options}  (table|nil) additional options
+      • {context}  (table) Context for the request
+      • {options}  (table|nil) additional options
                    • on_list: (function) handler for list results. See
                      |lsp-on-list-handler|
 
@@ -1256,9 +1196,9 @@ rename({new_name}, {options})                           *vim.lsp.buf.rename()*
     Renames all references to the symbol under the cursor.
 
     Parameters: ~
-        {new_name}  (string|nil) If not provided, the user will be prompted
+      • {new_name}  (string|nil) If not provided, the user will be prompted
                     for a new name using |vim.ui.input()|.
-        {options}   (table|nil) additional options
+      • {options}   (table|nil) additional options
                     • filter (function|nil): Predicate used to filter clients.
                       Receives a client as argument and must return a boolean.
                       Clients matching the predicate are included.
@@ -1280,7 +1220,7 @@ type_definition({options})                     *vim.lsp.buf.type_definition()*
     Jumps to the definition of the type of the symbol under the cursor.
 
     Parameters: ~
-        {options}  (table|nil) additional options
+      • {options}  (table|nil) additional options
                    • reuse_win: (boolean) Jump to existing window if buffer is
                      already open.
                    • on_list: (function) handler for list results. See
@@ -1294,8 +1234,8 @@ workspace_symbol({query}, {options})          *vim.lsp.buf.workspace_symbol()*
     string means no filtering is done.
 
     Parameters: ~
-        {query}    (string, optional)
-        {options}  (table|nil) additional options
+      • {query}    (string, optional)
+      • {options}  (table|nil) additional options
                    • on_list: (function) handler for list results. See
                      |lsp-on-list-handler|
 
@@ -1308,7 +1248,7 @@ get_namespace({client_id})                *vim.lsp.diagnostic.get_namespace()*
     |vim.diagnostic|.
 
     Parameters: ~
-        {client_id}  (number) The id of the LSP client
+      • {client_id}  (number) The id of the LSP client
 
                                  *vim.lsp.diagnostic.on_publish_diagnostics()*
 on_publish_diagnostics({_}, {result}, {ctx}, {config})
@@ -1337,7 +1277,7 @@ on_publish_diagnostics({_}, {result}, {ctx}, {config})
 <
 
     Parameters: ~
-        {config}  (table) Configuration table (see |vim.diagnostic.config()|).
+      • {config}  (table) Configuration table (see |vim.diagnostic.config()|).
 
 
 ==============================================================================
@@ -1347,15 +1287,15 @@ display({lenses}, {bufnr}, {client_id})           *vim.lsp.codelens.display()*
     Display the lenses using virtual text
 
     Parameters: ~
-        {lenses}     (table) of lenses to display (`CodeLens[] | null`)
-        {bufnr}      (number)
-        {client_id}  (number)
+      • {lenses}     (table) of lenses to display (`CodeLens[] | null`)
+      • {bufnr}      (number)
+      • {client_id}  (number)
 
 get({bufnr})                                          *vim.lsp.codelens.get()*
     Return all lenses for the given buffer
 
     Parameters: ~
-        {bufnr}  (number) Buffer number. 0 can be used for the current buffer.
+      • {bufnr}  (number) Buffer number. 0 can be used for the current buffer.
 
     Return: ~
         (table) (`CodeLens[]`)
@@ -1379,9 +1319,9 @@ save({lenses}, {bufnr}, {client_id})                 *vim.lsp.codelens.save()*
     Store lenses for a specific buffer and client
 
     Parameters: ~
-        {lenses}     (table) of lenses to store (`CodeLens[] | null`)
-        {bufnr}      (number)
-        {client_id}  (number)
+      • {lenses}     (table) of lenses to store (`CodeLens[] | null`)
+      • {bufnr}      (number)
+      • {client_id}  (number)
 
 
 ==============================================================================
@@ -1399,7 +1339,7 @@ hover({_}, {result}, {ctx}, {config})               *vim.lsp.handlers.hover()*
 <
 
     Parameters: ~
-        {config}  (table) Configuration table.
+      • {config}  (table) Configuration table.
                   • border: (default=nil)
                     • Add borders to the floating window