#language-server #lsp #tower

tower-lsp

Language Server Protocol implementation based on Tower

29 releases (19 breaking)

0.20.0 Aug 11, 2023
0.19.0 Feb 28, 2023
0.18.0 Jan 15, 2023
0.17.0 Apr 15, 2022
0.4.0 Oct 2, 2019

#3 in Text editors

Download history 12015/week @ 2023-11-01 12241/week @ 2023-11-08 12166/week @ 2023-11-15 11938/week @ 2023-11-22 13652/week @ 2023-11-29 14483/week @ 2023-12-06 14256/week @ 2023-12-13 9662/week @ 2023-12-20 9754/week @ 2023-12-27 13725/week @ 2024-01-03 14025/week @ 2024-01-10 14763/week @ 2024-01-17 16005/week @ 2024-01-24 14460/week @ 2024-01-31 16819/week @ 2024-02-07 13730/week @ 2024-02-14

63,454 downloads per month
Used in 60 crates (53 directly)

MIT/Apache

195KB
3K SLoC

tower-lsp

Build Status Crates.io Documentation

Language Server Protocol implementation for Rust based on Tower.

Tower is a simple and composable framework for implementing asynchronous services in Rust. Central to Tower is the Service trait, which provides the necessary abstractions for defining request/response clients and servers. Examples of protocols implemented using the Service trait include hyper for HTTP and tonic for gRPC.

This library (tower-lsp) provides a simple implementation of the Language Server Protocol (LSP) that makes it easy to write your own language server. It consists of three parts:

  • The LanguageServer trait which defines the behavior of your language server.
  • The asynchronous LspService delegate which wraps your language server implementation and defines the behavior of the protocol.
  • A Server which spawns the LspService and processes requests and responses over stdio or TCP.

Example

use tower_lsp::jsonrpc::Result;
use tower_lsp::lsp_types::*;
use tower_lsp::{Client, LanguageServer, LspService, Server};

#[derive(Debug)]
struct Backend {
    client: Client,
}

#[tower_lsp::async_trait]
impl LanguageServer for Backend {
    async fn initialize(&self, _: InitializeParams) -> Result<InitializeResult> {
        Ok(InitializeResult::default())
    }

    async fn initialized(&self, _: InitializedParams) {
        self.client
            .log_message(MessageType::INFO, "server initialized!")
            .await;
    }

    async fn shutdown(&self) -> Result<()> {
        Ok(())
    }
}

#[tokio::main]
async fn main() {
    let stdin = tokio::io::stdin();
    let stdout = tokio::io::stdout();

    let (service, socket) = LspService::new(|client| Backend { client });
    Server::new(stdin, stdout, socket).serve(service).await;
}

Using runtimes other than tokio

By default, tower-lsp is configured for use with tokio.

Using tower-lsp with other runtimes requires disabling default-features and enabling the runtime-agnostic feature:

[dependencies.tower-lsp]
version = "*"
default-features = false
features = ["runtime-agnostic"]

Using proposed features

You can use enable proposed features in the LSP Specification version 3.18 by enabling the proposed Cargo crate feature. Note that there are no semver guarantees to the proposed features so there may be breaking changes between any type of version in the proposed features.

Ecosystem

  • tower-lsp-boilerplate - Useful GitHub project template which makes writing new language servers easier.

License

tower-lsp is free and open source software distributed under the terms of either the MIT or the Apache 2.0 license, at your option.

Unless you explicitly state otherwise, any contribution intentionally submitted for inclusion in the work by you, as defined in the Apache-2.0 license, shall be dual licensed as above, without any additional terms or conditions.

Dependencies

~5–15MB
~178K SLoC