Language Server Protocol (LSP) server abstraction for Tower.

Example

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

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

#[deno_tower_lsp::async_trait(?Send)]
impl LanguageServer for Backend {
    async fn initialize(&self, _: InitializeParams) -> Result<InitializeResult> {
        Ok(InitializeResult {
            capabilities: ServerCapabilities {
                hover_provider: Some(HoverProviderCapability::Simple(true)),
                completion_provider: Some(CompletionOptions::default()),
                ..Default::default()
            },
            ..Default::default()
        })
    }

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

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

    async fn completion(&self, _: CompletionParams, _token: CancellationToken) -> Result<Option<CompletionResponse>> {
        Ok(Some(CompletionResponse::Array(vec![
            CompletionItem::new_simple("Hello".to_string(), "Some detail".to_string()),
            CompletionItem::new_simple("Bye".to_string(), "More detail".to_string())
        ])))
    }

    async fn hover(&self, _: HoverParams, _token: CancellationToken) -> Result<Option<Hover>> {
        Ok(Some(Hover {
            contents: HoverContents::Scalar(
                MarkedString::String("You're hovering!".to_string())
            ),
            range: None
        }))
    }
}

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

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

This is a fork of https://crates.io/crates/tower-lsp, used in Deno. At the moment only floating patches.