Async LSP

https://docs.rs/async-lsp/latest
Admin
An asynchronous Language Server Protocol (LSP) framework built on Tower for implementing language...
Tokens:123,671
Snippets:1,167
Trust Score:9.7
Update:5 months ago
Show doc for...
Tokens:
Raw
### Run Buffered LSP Service

Source: https://docs.rs/async-lsp/latest/src/async_lsp/lib.rs.html

Starts the LSP service's main loop, wrapping the input stream in a BufReader. Use this for convenience when the input is not already buffered.

```rust
pub async fn run_buffered(self, input: impl AsyncRead, output: impl AsyncWrite) -> Result<()> {
        self.run(BufReader::new(input), output).await
    }
```

--------------------------------

### Initialize Lifecycle Middleware

Source: https://docs.rs/async-lsp/latest/src/async_lsp/server.rs.html

Creates a new Lifecycle middleware instance. It starts in the Uninitialized state.

```rust
pub fn new(service: S) -> Self {
        Self {
            service,
            state: State::Uninitialized,
        }
    }
```

--------------------------------

### MainLoop Run Method

Source: https://docs.rs/async-lsp/latest/src/async_lsp/lib.rs.html

The `run` method of the MainLoop, which takes input and output streams and starts the LSP service. This is a test helper function.

```rust
fn _main_loop_future_is_send<S>(
        f: MainLoop<S>,
        input: impl AsyncBufRead + Send,
        output: impl AsyncWrite + Send,
    ) -> impl Send
    where
        S: LspService<Response = JsonValue> + Send,
        S::Future: Send,
        S::Error: From<Error> + Send,
        ResponseError: From<S::Error>,
    {
        f.run(input, output)
    }
```

--------------------------------

### Async Write with async-io

Source: https://docs.rs/async-lsp/latest/src/async_lsp/stdio.rs.html

Demonstrates writing to stdout using `async_io::Async` with `PipeStdout`. For `async-io` version 2 and later, the `async-io` feature must be enabled for `Async<PipeStdout>` to implement `AsyncRead` and `AsyncWrite`. The example shows both a conditional write and a write that always works.

```rust
# async fn work() -> std::io::Result<()> {
use futures::AsyncWriteExt;

let mut stdout = async_io::Async::new(async_lsp::stdio::PipeStdout::lock()?)
    ?;
// For `async-io` >= 2, this requires `async-io` feature to work.
#[cfg_attr(not(feature = "async-io"), doc = "# #[cfg(never)]")]
stdout.write_all(b"never spawns blocking tasks").await?;
// This always work.
(&stdout).write_all(b"never spawns blocking tasks").await?;
Ok(())
# }

```

--------------------------------

### initialize

Source: https://docs.rs/async-lsp/latest/async_lsp/struct.ServerSocket.html

Handles the `initialize` request.

```APIDOC
## initialize

### Description
Handles the `initialize` request from the client.

### Method
This is a request handler on the `ServerSocket` struct.

### Parameters
- `params`: Parameters for the `initialize` request.

### Response
Returns a future that resolves to the initialization result or an error.
```

--------------------------------

### Getting File Descriptor Source

Source: https://docs.rs/async-lsp/latest/async_lsp/stdio/struct.PipeStdout.html

Implements the `AsSource` trait, providing a method to get the borrowed file descriptor from `PipeStdout`. This is part of the trait's contract for accessing underlying file descriptors.

```rust
fn source(&self) -> BorrowedFd<'_>
```

--------------------------------

### Get Reference to Inner Service

Source: https://docs.rs/async-lsp/latest/async_lsp/tracing/struct.Tracing.html

Retrieves an immutable reference to the inner service wrapped by Tracing.

```APIDOC
## pub fn get_ref(&self) -> &S

Get a reference to the inner service.
```

--------------------------------

### take

Source: https://docs.rs/async-lsp/latest/async_lsp/stdio/struct.PipeStdin.html

Creates an adapter that reads at most a specified limit of bytes from the source.

```APIDOC
## fn take(self, limit: u64) -> Take<Self>

### Description
Creates an adapter which will read at most `limit` bytes from it.

### Parameters
#### Path Parameters
- `limit` (u64) - Description: The maximum number of bytes to read.

### Returns
- `Take<Self>` - An adapter that limits the number of bytes read.
```

--------------------------------

### Get Reference to Inner Service

Source: https://docs.rs/async-lsp/latest/async_lsp/panic/struct.CatchUnwind.html

Retrieves an immutable reference to the inner LspService wrapped by CatchUnwind.

```rust
pub fn get_ref(&self) -> &S
```

--------------------------------

### Create a Language Client main loop

Source: https://docs.rs/async-lsp/latest/async_lsp/struct.MainLoop.html

Initializes a MainLoop for a Language Client. It takes a builder function that constructs the service from a ServerSocket.

```rust
pub fn new_client( builder: impl FnOnce(ServerSocket) -> S, ) -> (Self, ServerSocket)
```

--------------------------------

### Create a Language Server main loop

Source: https://docs.rs/async-lsp/latest/async_lsp/struct.MainLoop.html

Initializes a MainLoop for a Language Server. It takes a builder function that constructs the service from a ClientSocket.

```rust
pub fn new_server( builder: impl FnOnce(ClientSocket) -> S, ) -> (Self, ClientSocket)
```

--------------------------------

### Get Mutable Reference to Inner Service

Source: https://docs.rs/async-lsp/latest/async_lsp/tracing/struct.Tracing.html

Retrieves a mutable reference to the inner service wrapped by Tracing.

```APIDOC
## pub fn get_mut(&mut self) -> &mut S

Get a mutable reference to the inner service.
```

--------------------------------

### initialize

Source: https://docs.rs/async-lsp/latest/async_lsp/trait.LanguageServer.html

Handles the initialization request from the client. This is a required method for any LanguageServer implementation.

```APIDOC
## initialize

### Description
Handles the initialization request from the client. This is a required method for any LanguageServer implementation.

### Method Signature
`fn initialize(&mut self, params: <Initialize as Request>::Params) -> BoxFuture<'static, Result<<Initialize as Request>::Result, Self::Error>>`

### Parameters
- `params`: The parameters for the Initialize request.

### Return Value
A `BoxFuture` that resolves to a `Result` containing the Initialize result or a `Self::Error`.
```

--------------------------------

### MainLoop Service Access

Source: https://docs.rs/async-lsp/latest/async_lsp/struct.MainLoop.html

Methods to get references or take ownership of the inner LspService managed by MainLoop.

```APIDOC
## get_ref

### Description
Get a reference to the inner service.

### Method
`get_ref(&self) -> &S`
```

```APIDOC
## get_mut

### Description
Get a mutable reference to the inner service.

### Method
`get_mut(&mut self) -> &mut S`
```

```APIDOC
## into_inner

### Description
Consume self, returning the inner service.

### Method
`into_inner(self) -> S`
```

--------------------------------

### MainLoop New Client Constructor

Source: https://docs.rs/async-lsp/latest/src/async_lsp/lib.rs.html

Creates a new `MainLoop` instance configured as a Language Client. It takes a builder function that initializes the service with a server socket.

```rust
/// Create a Language Client main loop.
#[must_use]
pub fn new_client(builder: impl FnOnce(ServerSocket) -> S) -> (Self, ServerSocket) {
    let (this, socket) = Self::new(|socket| builder(ServerSocket(socket)));
    (this, ServerSocket(socket))
}
```

--------------------------------

### Get Mutable Reference to Inner Service

Source: https://docs.rs/async-lsp/latest/async_lsp/panic/struct.CatchUnwind.html

Retrieves a mutable reference to the inner LspService wrapped by CatchUnwind.

```rust
pub fn get_mut(&mut self) -> &mut S
```

--------------------------------

### Result unwrap Panic Example

Source: https://docs.rs/async-lsp/latest/async_lsp/type.Result.html

Shows how `unwrap` panics when called on an `Err` variant, providing the error message.

```rust
let x: Result<u32, &str> = Err("emergency failure");
x.unwrap(); // panics with `emergency failure`
```

--------------------------------

### LifecycleLayer Construction and Usage

Source: https://docs.rs/async-lsp/latest/async_lsp/server/struct.LifecycleLayer.html

Demonstrates how to create a LifecycleLayer, clone it, and use its default value.

```APIDOC
## Struct LifecycleLayer

A `tower_layer::Layer` which builds `Lifecycle`.

### `impl Clone for LifecycleLayer`

#### `fn clone(&self) -> LifecycleLayer`
Returns a duplicate of the value.

#### `fn clone_from(&mut self, source: &Self)`
Performs copy-assignment from `source`.

### `impl Default for LifecycleLayer`

#### `fn default() -> LifecycleLayer`
Returns the “default value” for a type.

### `impl<S> Layer<S> for LifecycleLayer`

#### `type Service = Lifecycle<S>`
The wrapped service.

#### `fn layer(&self, inner: S) -> Self::Service`
Wrap the given service with the middleware, returning a new service that has been decorated with the middleware.
```

--------------------------------

### unwrap_or_default for Result

Source: https://docs.rs/async-lsp/latest/async_lsp/type.Result.html

Uses `unwrap_or_default` to get the contained value or the default if the `Result` is `Err`. This is useful for fallbacks when a default value is acceptable.

```rust
let good_year_from_input = "1909";
let bad_year_from_input = "190blarg";
let good_year = good_year_from_input.parse().unwrap_or_default();
let bad_year = bad_year_from_input.parse().unwrap_or_default();

assert_eq!(1909, good_year);
assert_eq!(0, bad_year);
```

--------------------------------

### MainLoop New Server Constructor

Source: https://docs.rs/async-lsp/latest/src/async_lsp/lib.rs.html

Creates a new `MainLoop` instance configured as a Language Server. It takes a builder function that initializes the service with a client socket.

```rust
/// Create a Language Server main loop.
#[must_use]
pub fn new_server(builder: impl FnOnce(ClientSocket) -> S) -> (Self, ClientSocket) {
    let (this, socket) = Self::new(|socket| builder(ClientSocket(socket)));
    (this, ClientSocket(socket))
}
```

--------------------------------

### Type ID Retrieval

Source: https://docs.rs/async-lsp/latest/async_lsp/concurrency/struct.Concurrency.html

Implements the Any trait, providing a method to get the TypeId of the current instance. This is useful for runtime type introspection.

```rust
fn type_id(&self) -> TypeId
```

--------------------------------

### Lifecycle Initialization

Source: https://docs.rs/async-lsp/latest/async_lsp/server/struct.Lifecycle.html

Constructor for creating a new `Lifecycle` middleware instance.

```APIDOC
## impl<S> Lifecycle<S>

### `new`

Creating the `Lifecycle` middleware in uninitialized state.

```rust
pub fn new(service: S) -> Self
```
```

--------------------------------

### Router::new

Source: https://docs.rs/async-lsp/latest/src/async_lsp/router.rs.html

Creates a new, empty `Router` with default unhandled handlers.

```APIDOC
## Router::new

### Description
Creates an empty `Router` instance, initializing it with default handlers for unhandled requests, notifications, and events.

### Method
`Router::new(state: St) -> Self`

### Parameters
- **state** (St) - The initial state for the router.
```

--------------------------------

### MainLoop Generic New Constructor

Source: https://docs.rs/async-lsp/latest/src/async_lsp/lib.rs.html

A private helper function to create a `MainLoop` instance, handling the setup of communication channels and the service.

```rust
fn new(builder: impl FnOnce(PeerSocket) -> S) -> (Self, PeerSocket) {
    let (tx, rx) = mpsc::unbounded();
    let socket = PeerSocket { tx };
    let this = Self {

```

--------------------------------

### Async I/O with async-io

Source: https://docs.rs/async-lsp/latest/async_lsp/stdio/index.html

Demonstrates using PipeStdout with async_io::Async for asynchronous writes. For async-io >= 2, the `async-io` feature must be enabled for Async<PipeStd{in,out}> to implement AsyncRead/AsyncWrite.

```rust
use futures::AsyncWriteExt;

let mut stdout = async_io::Async::new(async_lsp::stdio::PipeStdout::lock()?)?;
// For `async-io` >= 2, this requires `async-io` feature to work.
stdout.write_all(b"never spawns blocking tasks").await?;
// This always work.
(&stdout).write_all(b"never spawns blocking tasks").await?;
```

--------------------------------

### Collect Results into a Vector with Checked Addition

Source: https://docs.rs/async-lsp/latest/async_lsp/type.Result.html

Demonstrates collecting an iterator of `Result`s into a `Result` containing a `Vec`. This example checks for potential overflow during addition.

```rust
let v = vec![1, 2];
let res: Result<Vec<u32>, &'static str> = v.iter().map(|x: &u32| 
    x.checked_add(1).ok_or("Overflow!")
).collect();
assert_eq!(res, Ok(vec![2, 3]));
```

--------------------------------

### try_from

Source: https://docs.rs/async-lsp/latest/async_lsp/server/struct.ResponseFuture.html

Performs the conversion.

```APIDOC
## fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

### Description
Performs the conversion.
```

--------------------------------

### run

Source: https://docs.rs/async-lsp/latest/src/async_lsp/lib.rs.html

Drives the service main loop to provide the service, handling both incoming and outgoing messages asynchronously.

```APIDOC
## run

### Description
Drive the service main loop to provide the service.

### Signature
`pub async fn run(mut self, input: impl AsyncBufRead, output: impl AsyncWrite) -> Result<()>`

### Parameters
- `input`: An asynchronous readable stream implementing `AsyncBufRead`.
- `output`: An asynchronous writable stream.

### Errors
- `Error::Io`: when the underlying `input` or `output` raises an error.
- `Error::Deserialize`: when the peer sends undecodable or invalid message.
- `Error::Protocol`: when the peer violates Language Server Protocol.
- Other errors raised from service handlers.
```

--------------------------------

### ErrorCode Constants for LSP Reserved Range

Source: https://docs.rs/async-lsp/latest/async_lsp/struct.ErrorCode.html

These constants define the start and end of the reserved error code range for the Language Server Protocol (LSP). They are not actual error codes.

```rust
pub const LSP_RESERVED_ERROR_RANGE_START: Self
```

```rust
pub const LSP_RESERVED_ERROR_RANGE_END: Self
```

--------------------------------

### Initialize Router with Default Handlers

Source: https://docs.rs/async-lsp/latest/src/async_lsp/router.rs.html

Creates a new `Router` instance with default handlers for unhandled requests and notifications. The `state` is initialized using `Default::default()`.

```rust
impl<St, Error> Default for Router<St, Error>
where
    St: Default,
    Error: From<ResponseError> + Send + 'static,
{
    fn default() -> Self {
        Self::new(St::default())
    }
}
```

--------------------------------

### TracingBuilder::build() - Building the Tracing Middleware

Source: https://docs.rs/async-lsp/latest/async_lsp/tracing/type.TracingLayer.html

Builds the Tracing middleware with the current configuration, wrapping the provided service.

```rust
pub fn build<S>(&self, service: S) -> Tracing<S>
```

--------------------------------

### ErrorCode Constants for JSON-RPC Reserved Range

Source: https://docs.rs/async-lsp/latest/async_lsp/struct.ErrorCode.html

These constants define the start and end of the reserved error code range for JSON-RPC. They do not represent actual error codes but are used for compatibility.

```rust
pub const JSONRPC_RESERVED_ERROR_RANGE_START: Self
```

```rust
pub const JSONRPC_RESERVED_ERROR_RANGE_END: Self
```

--------------------------------

### Collect Results into a Vector with Checked Subtraction (Success)

Source: https://docs.rs/async-lsp/latest/async_lsp/type.Result.html

Shows collecting an iterator of `Result`s into a `Result` containing a `Vec` when all operations succeed. This example checks for potential underflow during subtraction.

```rust
let v = vec![1, 2];
let res: Result<Vec<u32>, &'static str> = v.iter().map(|x: &u32| 
    x.checked_sub(1).ok_or("Underflow!")
).collect();
assert_eq!(res, Ok(vec![0, 1]));
```

--------------------------------

### implementation

Source: https://docs.rs/async-lsp/latest/async_lsp/trait.LanguageServer.html

Handles requests for code implementations (e.g., Go to Implementation). This is a provided method.

```APIDOC
## implementation

### Description
Handles requests for code implementations (e.g., Go to Implementation). This is a provided method.

### Method Signature
`fn implementation(&mut self, params: <GotoImplementation as Request>::Params) -> BoxFuture<'static, Result<<GotoImplementation as Request>::Result, Self::Error>>`

### Parameters
- `params`: The parameters for the GotoImplementation request.

### Return Value
A `BoxFuture` that resolves to a `Result` containing the implementation details or a `Self::Error`.
```

--------------------------------

### Access Inner Service

Source: https://docs.rs/async-lsp/latest/async_lsp/server/struct.Lifecycle.html

Provides methods to get immutable or mutable references to the inner service held by the Lifecycle middleware. It also allows consuming the middleware to retrieve the inner service.

```rust
pub fn get_ref(&self) -> &S
```

```rust
pub fn get_mut(&mut self) -> &mut S
```

```rust
pub fn into_inner(self) -> S
```

--------------------------------

### Handle Incoming Requests in Lifecycle Middleware

Source: https://docs.rs/async-lsp/latest/src/async_lsp/server.rs.html

Manages incoming requests based on the server's current state. It transitions from Uninitialized to Initializing upon receiving an Initialize request, and handles other requests differently based on whether the server is Ready or ShuttingDown.

```rust
fn call(&mut self, req: AnyRequest) -> Self::Future {
        let inner = match (self.state, &*req.method) {
            (State::Uninitialized, request::Initialize::METHOD) => {
                self.state = State::Initializing;
                Either::Left(self.service.call(req))
            }
            (State::Uninitialized | State::Initializing, _) => {
                Either::Right(ready(Err(ResponseError {
                    code: ErrorCode::SERVER_NOT_INITIALIZED,
                    message: "Server is not initialized yet".into(),
                    data: None,
                }
                .into())))
            }
            (_, request::Initialize::METHOD) => Either::Right(ready(Err(ResponseError {
                code: ErrorCode::INVALID_REQUEST,
                message: "Server is already initialized".into(),
                data: None,
            }
            .into()))),
            (State::Ready, _) => {
                if req.method == request::Shutdown::METHOD {
                    self.state = State::ShuttingDown;
                }
                Either::Left(self.service.call(req))
            }
            (State::ShuttingDown, _) => Either::Right(ready(Err(ResponseError {
                code: ErrorCode::INVALID_REQUEST,
                message: "Server is shutting down".into(),
                data: None,
            }
            .into()))),
        };
        ResponseFuture { inner }
```

--------------------------------

### Collect Results into a Vector with Checked Subtraction (Failure)

Source: https://docs.rs/async-lsp/latest/async_lsp/type.Result.html

Illustrates collecting an iterator of `Result`s where an error occurs. The `collect` method stops at the first `Err` and returns it. This example checks for underflow during subtraction.

```rust
let v = vec![1, 2, 0];
let res: Result<Vec<u32>, &'static str> = v.iter().map(|x: &u32| 
    x.checked_sub(1).ok_or("Underflow!")
).collect();
assert_eq!(res, Err("Underflow!"));
```

--------------------------------

### Get Metadata with Fallible Operations

Source: https://docs.rs/async-lsp/latest/async_lsp/type.Result.html

Demonstrates using `and_then` with file system operations that can fail. `metadata()` returns a Result, and `and_then` is used to chain further operations or handle potential errors like 'NotFound'.

```rust
use std::{io::ErrorKind, path::Path};

// Note: on Windows "/" maps to "C:\\"
let root_modified_time = Path::new("/").metadata().and_then(|md| md.modified());
assert!(root_modified_time.is_ok());

let should_fail = Path::new("/bad/path").metadata().and_then(|md| md.modified());
assert!(should_fail.is_err());
assert_eq!(should_fail.unwrap_err().kind(), ErrorKind::NotFound);
```

--------------------------------

### Getting References to Result Values

Source: https://docs.rs/async-lsp/latest/async_lsp/type.Result.html

Use `as_ref()` to obtain a `Result<&T, &E>` from a `&Result<T, E>`, allowing inspection of the contained values without consuming the original Result. `as_mut()` provides mutable references.

```rust
let x: Result<u32, &str> = Ok(2);
assert_eq!(x.as_ref(), Ok(&2));

let x: Result<u32, &str> = Err("Error");
assert_eq!(x.as_ref(), Err(&"Error"));
```

```rust
fn mutate(r: &mut Result<i32, i32>) {
    match r.as_mut() {
        Ok(v) => *v = 42,
        Err(e) => *e = 0,
    }
}

let mut x: Result<i32, i32> = Ok(2);
mutate(&mut x);
assert_eq!(x.unwrap(), 42);

let mut x: Result<i32, i32> = Err(13);
mutate(&mut x);
assert_eq!(x.unwrap_err(), 0);
```

--------------------------------

### into_ok

Source: https://docs.rs/async-lsp/latest/async_lsp/type.Result.html

Returns the contained Ok value, never panics. This is a nightly-only experimental API.

```APIDOC
## into_ok

### Description
Returns the contained `Ok` value, but never panics. Unlike `unwrap`, this method is known to never panic on the result types it is implemented for. Therefore, it can be used instead of `unwrap` as a maintainability safeguard that will fail to compile if the error type of the `Result` is later changed to an error that can actually occur.

### Method
`into_ok()`

### Constraints
Requires `E` to implement `Into<!>`.

### Status
Nightly-only experimental API.

### Examples
```rust
fn only_good_news() -> Result<String, !> {
    Ok("this is fine".into())
}

let s: String = only_good_news().into_ok();
println!("{s}");
```
```

--------------------------------

### PipeStdout::try_into_tokio

Source: https://docs.rs/async-lsp/latest/async_lsp/stdio/struct.PipeStdout.html

Registers the FD to the Tokio runtime and returns a Tokio compatible writer. Available on crate feature `tokio` only. Fails if cannot create `AsyncFd`.

```APIDOC
## pub fn try_into_tokio(self) -> Result<TokioPipeStdout>

Available on **crate feature`tokio`** only.
Register the FD to the tokio runtime and return a tokio compatible writer.

### Errors
Fails if cannot create `AsyncFd`.
```

--------------------------------

### Create Lifecycle Instance

Source: https://docs.rs/async-lsp/latest/async_lsp/server/struct.Lifecycle.html

Constructs a new Lifecycle middleware instance, initializing it with the provided service. This is the entry point for integrating the Lifecycle management.

```rust
pub fn new(service: S) -> Self
```

--------------------------------

### TracingBuilder::build

Source: https://docs.rs/async-lsp/latest/async_lsp/tracing/type.TracingLayer.html

Builds the middleware with the current configuration, wrapping the provided service.

```APIDOC
## TracingBuilder::build

### Description
Build the middleware with the current configuration.

### Signature
```rust
pub fn build<S>(&self, service: S) -> Tracing<S>
```
```

--------------------------------

### into_ok for Result (Nightly)

Source: https://docs.rs/async-lsp/latest/async_lsp/type.Result.html

Illustrates `into_ok`, a nightly-only experimental API that returns the contained `Ok` value without panicking. It's a compile-time safeguard against potential errors.

```rust
fn only_good_news() -> Result<String, !> {
    Ok("this is fine".into())
}

let s: String = only_good_news().into_ok();
println!("{s}");
```

--------------------------------

### Converting to TokioPipeStdout

Source: https://docs.rs/async-lsp/latest/async_lsp/stdio/struct.PipeStdout.html

Registers the file descriptor with the Tokio runtime to return a Tokio-compatible writer. Fails if `AsyncFd` cannot be created. Available on crate feature `tokio` only.

```rust
pub fn try_into_tokio(self) -> Result<TokioPipeStdout>
```

--------------------------------

### implementation

Source: https://docs.rs/async-lsp/latest/async_lsp/struct.ServerSocket.html

Handles the `textDocument/implementation` request.

```APIDOC
## implementation

### Description
Handles the `textDocument/implementation` request from the client.

### Method
This is a request handler on the `ServerSocket` struct.

### Parameters
- `params`: Parameters for the `textDocument/implementation` request.

### Response
Returns a future that resolves to the implementation locations or an error.
```

--------------------------------

### run_buffered

Source: https://docs.rs/async-lsp/latest/src/async_lsp/lib.rs.html

Drives the service main loop, accepting an `impl AsyncRead` and implicitly wrapping it in a `BufReader` for buffered reading.

```APIDOC
## run_buffered

### Description
Shortcut to [`MainLoop::run`] that accepts an `impl AsyncRead` and implicitly wraps it in a [`BufReader`].

### Signature
`pub async fn run_buffered(self, input: impl AsyncRead, output: impl AsyncWrite) -> Result<()>`

### Parameters
- `input`: An asynchronous readable stream that will be buffered.
- `output`: An asynchronous writable stream.

### Returns
A `Result<()>` indicating success or failure.
```

--------------------------------

### Create an empty Router

Source: https://docs.rs/async-lsp/latest/async_lsp/router/struct.Router.html

Use `Router::new` to create an empty router instance, providing the initial state.

```rust
pub fn new(state: St) -> Self
```

--------------------------------

### Read Implementation for &PipeStdin - Take

Source: https://docs.rs/async-lsp/latest/async_lsp/stdio/struct.PipeStdin.html

Creates an adapter that reads at most a specified limit of bytes. Available since 1.0.0.

```rust
fn take(self, limit: u64) -> Take<Self>
```

--------------------------------

### Create a new TracingBuilder

Source: https://docs.rs/async-lsp/latest/src/async_lsp/tracing.rs.html

Initializes a `TracingBuilder` with all span configurations set to `None`. This allows for explicit configuration of which spans to enable.

```rust
pub fn new() -> Self {
    Self {
        service_ready: None,
        request: None,
        notification: None,
        event: None,
    }
}
```

--------------------------------

### CatchUnwindBuilder Default Configuration

Source: https://docs.rs/async-lsp/latest/src/async_lsp/panic.rs.html

This implementation of `Default` for `CatchUnwindBuilder` sets up the builder with the `default_handler`. This is useful for creating a `CatchUnwind` middleware with standard panic handling behavior.

```rust
impl Default for CatchUnwindBuilder<ResponseError> {
    fn default() -> Self {
        Self::new_with_handler(default_handler)
    }
}
```

--------------------------------

### Router from_language_server Method

Source: https://docs.rs/async-lsp/latest/src/async_lsp/omni_trait.rs.html

This method creates a Router from an existing LanguageServer implementation, setting up handlers for requests and notifications.

```APIDOC
## Router::from_language_server

### Description
Creates a [`Router`] using its implementation of [`LanguageServer`] as handlers.

### Parameters
- `state`: An implementation of the `LanguageServer` trait.

### Returns
A new `Router` instance.

### Usage
```rust
let router = Router::from_language_server(my_language_server_impl);
```
```

--------------------------------

### Initialize Tracing Middleware

Source: https://docs.rs/async-lsp/latest/src/async_lsp/tracing.rs.html

Initializes the `Tracing` middleware with a default `TracingBuilder`. This middleware wraps an existing `LspService` to add tracing capabilities.

```rust
impl<S: LspService> LspService for Tracing<S> {
    fn notify(&mut self, notif: AnyNotification) -> ControlFlow<Result<()>> {
        let _guard = self.spans.notification.map(|f| f(&notif).entered());
        self.service.notify(notif)
    }

    fn emit(&mut self, event: AnyEvent) -> ControlFlow<Result<()>> {
        let _guard = self.spans.event.map(|f| f(&event).entered());
        self.service.emit(event)
    }
}
```

--------------------------------

### Run main loop with buffered input

Source: https://docs.rs/async-lsp/latest/async_lsp/struct.MainLoop.html

Drives the service main loop using asynchronous I/O. This version accepts an AsyncRead and implicitly wraps it in a BufReader.

```rust
pub async fn run_buffered( self, input: impl AsyncRead, output: impl AsyncWrite, ) -> Result<()>
```

--------------------------------

### by_ref

Source: https://docs.rs/async-lsp/latest/async_lsp/stdio/struct.PipeStdin.html

Creates a "by reference" adapter for this Read instance.

```APIDOC
## fn by_ref(&mut self) -> &mut Self

### Description
Creates a “by reference” adapter for this instance of `Read`.

### Returns
- `&mut Self` - A mutable reference to the adapter.
```

--------------------------------

### Create Router from LanguageClient

Source: https://docs.rs/async-lsp/latest/async_lsp/router/struct.Router.html

Create a `Router` by leveraging handlers from a `LanguageClient` implementation. This functionality requires the `omni-trait` crate feature to be enabled.

```rust
pub fn from_language_client(state: S) -> Self
```

--------------------------------

### Try Into Tokio PipeStdin

Source: https://docs.rs/async-lsp/latest/async_lsp/stdio/struct.PipeStdin.html

Registers the file descriptor with the Tokio runtime to return a Tokio-compatible reader. Available on crate feature `tokio` only. Fails if cannot create `AsyncFd`.

```rust
pub fn try_into_tokio(self) -> Result<TokioPipeStdin>
```

--------------------------------

### Create Router from LanguageServer

Source: https://docs.rs/async-lsp/latest/async_lsp/router/struct.Router.html

Instantiate a `Router` using handlers derived from a `LanguageServer` implementation. This feature is only available when the `omni-trait` crate feature is enabled.

```rust
pub fn from_language_server(state: S) -> Self
```

--------------------------------

### CatchUnwind Service Implementation

Source: https://docs.rs/async-lsp/latest/async_lsp/panic/struct.CatchUnwind.html

Handles incoming requests, returning futures for responses and managing service readiness.

```APIDOC
## `poll_ready`

### Description
Returns `Poll::Ready(Ok(()))` when the service is able to process requests.

### Signature
```rust
fn poll_ready(&mut self, cx: &mut Context<'_>) -> Poll<Result<(), Self::Error>>
```

## `call`

### Description
Process the request and return the response asynchronously.

### Signature
```rust
fn call(&mut self, req: AnyRequest) -> Self::Future
```

### Associated Types
- `Response`: Responses given by the service.
- `Error`: Errors produced by the service.
- `Future`: The future response value.
```

--------------------------------

### Signature Help Request

Source: https://docs.rs/async-lsp/latest/async_lsp/struct.ServerSocket.html

Provides signature help for the current cursor position.

```APIDOC
## signature_help

### Description
Provides signature help for the current cursor position.

### Method
`signature_help`

### Parameters
- `params`: Parameters for the signature help request.

### Returns
A future that resolves to the signature help result or an error.
```

--------------------------------

### Read Implementation for &PipeStdin - By Reference

Source: https://docs.rs/async-lsp/latest/async_lsp/stdio/struct.PipeStdin.html

Creates a "by reference" adapter for the reader. Available since 1.0.0.

```rust
fn by_ref(&mut self) -> &mut Self
```

--------------------------------

### signature_help

Source: https://docs.rs/async-lsp/latest/async_lsp/struct.ServerSocket.html

Handles requests for signature help.

```APIDOC
## signature_help

### Description
Handles requests for signature help.

### Method
`signature_help`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **params** (<SignatureHelpRequest as Request>::Params) - Required - Parameters for the signature help request.

### Request Example
```json
{
  "example": "request body for signature_help"
}
```

### Response
#### Success Response (200)
- **result** (<SignatureHelpRequest as Request>::Result) - The result of the signature help request.

#### Response Example
```json
{
  "example": "response body for signature_help"
}
```
```

--------------------------------

### boxed

Source: https://docs.rs/async-lsp/latest/async_lsp/server/struct.ResponseFuture.html

Wraps the future in a Box, pinning it. Available on `crate feature`alloc` only.

```APIDOC
## fn boxed<'a>(self) -> Pin<Box<dyn Future<Output = Self::Output> + Send + 'a>>

### Description
Wrap the future in a Box, pinning it.

### Availability
Available on `crate feature`alloc` only.
```

--------------------------------

### initialized

Source: https://docs.rs/async-lsp/latest/async_lsp/struct.ServerSocket.html

Handles the `initialized` notification.

```APIDOC
## initialized

### Description
Handles the `initialized` notification from the client.

### Method
This is a notification handler on the `ServerSocket` struct.

### Parameters
- `params`: Parameters for the `initialized` notification.
```

--------------------------------

### boxed_local

Source: https://docs.rs/async-lsp/latest/async_lsp/server/struct.ResponseFuture.html

Wraps the future in a Box, pinning it. Available on `crate feature`alloc` only.

```APIDOC
## fn boxed_local<'a>(self) -> Pin<Box<dyn Future<Output = Self::Output> + 'a>>

### Description
Wrap the future in a Box, pinning it.

### Availability
Available on `crate feature`alloc` only.
```

--------------------------------

### MainLoop Execution

Source: https://docs.rs/async-lsp/latest/async_lsp/struct.MainLoop.html

Methods to drive the service main loop with input and output streams.

```APIDOC
## run_buffered

### Description
Drive the service main loop to provide the service. Shortcut to `MainLoop::run` that accept an `impl AsyncRead` and implicit wrap it in a `BufReader`.

### Method
`run_buffered(self, input: impl AsyncRead, output: impl AsyncWrite) -> Result<()>`
```

```APIDOC
## run

### Description
Drive the service main loop to provide the service.

### Method
`run(self, input: impl AsyncBufRead, output: impl AsyncWrite) -> Result<()>`

### Errors
  * `Error::Io` when the underlying `input` or `output` raises an error.
  * `Error::Deserialize` when the peer sends undecodable or invalid message.
  * `Error::Protocol` when the peer violates Language Server Protocol.
  * Other errors raised from service handlers.
```

--------------------------------

### Create ClientProcessMonitorBuilder

Source: https://docs.rs/async-lsp/latest/async_lsp/client_monitor/struct.ClientProcessMonitorBuilder.html

Instantiates a new ClientProcessMonitorBuilder with a given ClientSocket. This is used to inject exit events into the monitoring middleware.

```rust
pub fn new(client: ClientSocket) -> Self
```

--------------------------------

### will_create_files

Source: https://docs.rs/async-lsp/latest/async_lsp/struct.ServerSocket.html

Handles pre-notification for file creation operations.

```APIDOC
## will_create_files

### Description
Handles pre-notification for file creation operations.

### Method
`will_create_files`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **params** (<WillCreateFiles as Request>::Params) - Required - Parameters for the will create files notification.

### Request Example
```json
{
  "example": "request body for will_create_files"
}
```

### Response
#### Success Response (200)
- **result** (<WillCreateFiles as Request>::Result) - The result of the will create files operation.

#### Response Example
```json
{
  "example": "response body for will_create_files"
}
```
```

--------------------------------

### inlay_hint

Source: https://docs.rs/async-lsp/latest/async_lsp/struct.ServerSocket.html

Handles requests for inlay hints.

```APIDOC
## inlay_hint

### Description
Handles requests for inlay hints.

### Method
`inlay_hint`

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **params** (<InlayHintRequest as Request>::Params) - Required - Parameters for the inlay hint request.

### Request Example
```json
{
  "example": "request body for inlay_hint"
}
```

### Response
#### Success Response (200)
- **result** (<InlayHintRequest as Request>::Result) - The result of the inlay hint request.

#### Response Example
```json
{
  "example": "response body for inlay_hint"
}
```
```

--------------------------------

### TracingBuilder::new

Source: https://docs.rs/async-lsp/latest/async_lsp/tracing/struct.TracingBuilder.html

Creates a new TracingBuilder with no spans configured. This is distinct from `default()` which configures all default spans.

```APIDOC
## TracingBuilder::new

### Description
Creates the builder with no spans configured.
NB. This is **NOT** the same as `TracingBuilder::default` which configures ALL default spans.

### Signature
```rust
pub fn new() -> Self
```
```

--------------------------------

### TracingBuilder::service_ready() - Instrumenting Service::poll_ready

Source: https://docs.rs/async-lsp/latest/async_lsp/tracing/type.TracingLayer.html

Configures a tracing::Span builder to instrument the Service::poll_ready method. Accepts a function that returns a Span.

```rust
pub fn service_ready(self, f: fn() -> Span) -> Self
```

--------------------------------

### Create Empty Router

Source: https://docs.rs/async-lsp/latest/src/async_lsp/router.rs.html

Initializes an empty `Router` with the provided state. Default handlers are set up to respond to unknown methods or break on unhandled notifications/events.

```rust
pub fn new(state: St) -> Self {
    Self {
        state,
        req_handlers: HashMap::new(),
        notif_handlers: HashMap::new(),
        event_handlers: HashMap::new(),
        unhandled_req: Box::new(|_, req| {
            Box::pin(ready(Err(ResponseError {
                code: ErrorCode::METHOD_NOT_FOUND,
                message: format!("No such method {}", req.method),
                data: None,
            }
            .into())))
        }),
        unhandled_notif: Box::new(|_, notif| {
            if notif.method.starts_with("$/") {
                ControlFlow::Continue(())
            } else {
                ControlFlow::Break(Err(crate::Error::Routing(format!(
                    "Unhandled notification: {}",
                    notif.method,
                ))))
            }
        }),
        unhandled_event: Box::new(|_, event| {
            ControlFlow::Break(Err(crate::Error::Routing(format!(
                "Unhandled event: {event:?}"
            ))))
        }),
    }
}
```

--------------------------------

### Default ConcurrencyBuilder Configuration

Source: https://docs.rs/async-lsp/latest/src/async_lsp/concurrency.rs.html

Provides a default configuration for `ConcurrencyBuilder` using available parallelism, falling back to 1 if it fails.

```rust
impl Default for ConcurrencyBuilder {
    fn default() -> Self {
        Self::new(available_parallelism().unwrap_or(NonZeroUsize::new(1).unwrap()))
    }
}
```

--------------------------------

### inspect_ok

Source: https://docs.rs/async-lsp/latest/async_lsp/panic/struct.ResponseFuture.html

Performs an action with the success value of a future before passing it on.

```APIDOC
## fn inspect_ok<F>(self, f: F) -> InspectOk<Self, F>

### Description
Do something with the success value of a future before passing it on.

### Parameters
* `f`: FnOnce(&Self::Ok) - A closure that takes a reference to the success value.

### Type Constraints
* `F`: Must be a closure that takes `&Self::Ok`.
* `Self`: Must be `Sized`.
```

--------------------------------

### Will Create Files Request

Source: https://docs.rs/async-lsp/latest/async_lsp/struct.ServerSocket.html

Handles requests before files are created.

```APIDOC
## fn will_create_files

### Description
Handles requests before files are created.

### Method
(Implicitly a request method)

### Endpoint
(Not applicable, SDK method)

### Parameters
#### Path Parameters
None

#### Query Parameters
None

#### Request Body
- **params** (<WillCreateFiles as Request>::Params) - The parameters for the will create files request.
```

--------------------------------

### Execute Command

Source: https://docs.rs/async-lsp/latest/async_lsp/trait.LanguageServer.html

Executes a given command with specified parameters.

```APIDOC
## execute_command

### Description
Executes a command.

### Method
(Implicitly defined by trait method signature)

### Parameters
- `params` (`<ExecuteCommand as Request>::Params`): The parameters for the execute command request.

### Response
- `BoxFuture<'static, Result<<ExecuteCommand as Request>::Result, Self::Error>>`: A future that resolves to the result of the command execution or an error.
```

--------------------------------

### MainLoop Creation

Source: https://docs.rs/async-lsp/latest/async_lsp/struct.MainLoop.html

Functions to create a new MainLoop instance for either a server or a client.

```APIDOC
## new_server

### Description
Create a Language Server main loop.

### Method
`new_server(builder: impl FnOnce(ClientSocket) -> S) -> (Self, ClientSocket)`
```

```APIDOC
## new_client

### Description
Create a Language Client main loop.

### Method
`new_client(builder: impl FnOnce(ServerSocket) -> S) -> (Self, ServerSocket)`
```

--------------------------------

### Router::from_language_server

Source: https://docs.rs/async-lsp/latest/async_lsp/router/struct.Router.html

Creates a `Router` using handlers derived from an implementation of the `LanguageServer` trait. This feature is available only when the `omni-trait` crate feature is enabled.

```APIDOC
## Router::from_language_server

### Description
Create a `Router` using its implementation of `LanguageServer` as handlers. Available on **crate feature`omni-trait`** only.

### Signature
```rust
pub fn from_language_server(state: S) -> Self
where
    S: LanguageServer<NotifyResult = ControlFlow<Result<()>>>,
```

### Parameters
* **state** (`S`): An object implementing the `LanguageServer` trait.
```

--------------------------------

### Service<AnyRequest> Methods

Source: https://docs.rs/async-lsp/latest/async_lsp/struct.ServerSocket.html

Methods for processing arbitrary LSP requests using the Service trait.

```APIDOC
## fn poll_ready

### Description
Returns `Poll::Ready(Ok(()))` when the service is able to process requests.

### Method
Readiness Check

### Parameters
- **_cx** (`&mut Context<'_>`) - The current context for polling.

### Response
- **Poll<Result<(), Self::Error>>** - The polling result indicating readiness.
```

```APIDOC
## fn call

### Description
Process the request and return the response asynchronously.

### Method
Request Processing

### Parameters
- **req** (`AnyRequest`) - The LSP request to process.

### Response
- **Self::Future** - A future that resolves to the response of the request.
```

--------------------------------

### progress

Source: https://docs.rs/async-lsp/latest/async_lsp/struct.ServerSocket.html

Handles the `$/progress` notification.

```APIDOC
## progress

### Description
Handles the `$/progress` notification from the client.

### Method
This is a notification handler on the `ServerSocket` struct.

### Parameters
- `params`: Parameters for the `$/progress` notification.
```

--------------------------------

### Signature Help

Source: https://docs.rs/async-lsp/latest/async_lsp/trait.LanguageServer.html

Provides signature help for a given position.

```APIDOC
## signature_help

### Description
Provides signature help for a given position.

### Method
Not applicable (trait method)

### Parameters
- **params** (<SignatureHelpRequest as Request>::Params) - Description of parameters for signature help request.
```

--------------------------------

### did_change_configuration

Source: https://docs.rs/async-lsp/latest/async_lsp/struct.ServerSocket.html

Handles the `didChangeConfiguration` notification.

```APIDOC
## did_change_configuration

### Description
Handles the `didChangeConfiguration` notification from the client.

### Method
This is a notification handler on the `ServerSocket` struct.

### Parameters
- `params`: Parameters for the `didChangeConfiguration` notification.
```

--------------------------------

### into

Source: https://docs.rs/async-lsp/latest/async_lsp/server/struct.ResponseFuture.html

Calls `U::from(self)`. This conversion is whatever the implementation of `From<T> for U` chooses to do.

```APIDOC
## fn into(self) -> U

### Description
Calls `U::from(self)`.

That is, this conversion is whatever the implementation of `From<T> for U` chooses to do.
```

--------------------------------

### Execute Command

Source: https://docs.rs/async-lsp/latest/async_lsp/trait.LanguageServer.html

Executes a command on the language server.

```APIDOC
## execute_command

### Description
Executes a command on the language server.

### Method
`execute_command`

### Parameters
- `params`: Parameters for the execute command request.

### Returns
A future that resolves to the result of the command execution or an error.
```

--------------------------------

### Implement LanguageClient for ClientSocket

Source: https://docs.rs/async-lsp/latest/src/async_lsp/omni_trait.rs.html

Implements the LanguageClient trait for a given type, handling requests and notifications. This macro is used to generate the necessary trait implementations.

```rust
macro_rules! impl_client_socket {
            ($ty:ty) => {
                impl LanguageClient for $ty {
                    type Error = crate::Error;
                    type NotifyResult = crate::Result<()>;

                    // Requests.
                    $( 
                    fn $req_snake(
                        &mut self,
                        params: <$req as Request>::Params,
                    ) -> ResponseFuture<$req, Self::Error> {
                        Box::pin(self.0.request::<$req>(params))
                    }
                    )*

                    // Notifications.
                    $( 
                    fn $notif_snake(
                        &mut self,
                        params: <$notif as Notification>::Params,
                    ) -> Self::NotifyResult {
                        self.notify::<$notif>(params)
                    }
                    )*
                }
            };
        }
```

--------------------------------

### TracingBuilder::build

Source: https://docs.rs/async-lsp/latest/src/async_lsp/tracing.rs.html

Builds a Tracing service from a given service.

```APIDOC
## TracingBuilder::build

### Description
Builds a `Tracing` service by wrapping the provided inner service with tracing capabilities.

### Method
`build<S>(&self, service: S) -> Tracing<S>`

### Parameters
- `service`: The inner service to wrap with tracing.

### Returns
A `Tracing` service instance.
```

--------------------------------

### ConcurrencyBuilder::default

Source: https://docs.rs/async-lsp/latest/async_lsp/concurrency/struct.ConcurrencyBuilder.html

Provides the default configuration for ConcurrencyBuilder.

```APIDOC
## fn default() -> Self

### Description
Returns the default value for a type. The default configuration has `max_concurrency` set to the result of `std::thread::available_parallelism`, falling back to `1` if it fails.
```

--------------------------------

### Blanket Implementations for ResponseFuture

Source: https://docs.rs/async-lsp/latest/async_lsp/panic/struct.ResponseFuture.html

Details blanket implementations available for `ResponseFuture`, including traits like `Any`, `Borrow`, `BorrowMut`, `From`, and `FutureExt`.

```APIDOC
## Blanket Implementations

### impl<T> Any for T

#### fn type_id(&self) -> TypeId

### impl<T> Borrow<T> for T

#### fn borrow(&self) -> &T

### impl<T> BorrowMut<T> for T

#### fn borrow_mut(&mut self) -> &mut T

### impl<T> From<T> for T

#### fn from(t: T) -> T

### impl<F> FutureExt for F

#### fn poll(&mut self, cx: &mut Context<'_>) -> Poll<Self::Output>

#### fn or<F>(self, other: F) -> Or<Self, F>

### impl<T> FutureExt for T

#### fn map<U, F>(self, f: F) -> Map<Self, F>

#### fn map_into<U>(self) -> MapInto<Self, U>

#### fn then<Fut, F>(self, f: F) -> Then<Self, Fut, F>

#### fn left_future<B>(self) -> Either<Self, B>

#### fn right_future<A>(self) -> Either<A, Self>

#### fn into_stream(self) -> IntoStream<Self>

#### fn flatten(self) -> Flatten<Self>

#### fn flatten_stream(self) -> FlattenStream<Self>

#### fn fuse(self) -> Fuse<Self>

#### fn inspect<F>(self, f: F) -> Inspect<Self, F>

#### fn catch_unwind(self) -> CatchUnwind<Self>
```

--------------------------------

### LspService Methods

Source: https://docs.rs/async-lsp/latest/async_lsp/struct.ServerSocket.html

Methods for handling LSP notifications directly on the ServerSocket.

```APIDOC
## fn will_save

### Description
Handles the `WillSaveTextDocument` notification.

### Method
Notification

### Parameters
- **params** (`<WillSaveTextDocument as Notification>::Params`) - Description of the parameters for the WillSaveTextDocument notification.

### Response
- **NotifyResult** - The result of the notification handler.
```

```APIDOC
## fn did_change_watched_files

### Description
Handles the `DidChangeWatchedFiles` notification.

### Method
Notification

### Parameters
- **params** (`<DidChangeWatchedFiles as Notification>::Params`) - Description of the parameters for the DidChangeWatchedFiles notification.

### Response
- **NotifyResult** - The result of the notification handler.
```

```APIDOC
## fn set_trace

### Description
Handles the `SetTrace` notification.

### Method
Notification

### Parameters
- **params** (`<SetTrace as Notification>::Params`) - Description of the parameters for the SetTrace notification.

### Response
- **NotifyResult** - The result of the notification handler.
```

```APIDOC
## fn cancel_request

### Description
Handles the `Cancel` notification for request cancellation.

### Method
Notification

### Parameters
- **params** (`<Cancel as Notification>::Params`) - Description of the parameters for the Cancel notification.

### Response
- **NotifyResult** - The result of the notification handler.
```

```APIDOC
## fn progress

### Description
Handles the `Progress` notification.

### Method
Notification

### Parameters
- **params** (`<Progress as Notification>::Params`) - Description of the parameters for the Progress notification.

### Response
- **NotifyResult** - The result of the notification handler.
```

```APIDOC
## fn notify

### Description
The handler of LSP notifications.

### Method
Notification Handler

### Parameters
- **notif** (`AnyNotification`) - The LSP notification to handle.

### Response
- **ControlFlow<Result<()>>** - Control flow indicating how to proceed after handling the notification.
```

```APIDOC
## fn emit

### Description
The handler of an arbitrary `AnyEvent`.

### Method
Event Handler

### Parameters
- **event** (`AnyEvent`) - The arbitrary event to handle.

### Response
- **ControlFlow<Result<()>>** - Control flow indicating how to proceed after handling the event.
```
Tokens:
Raw