add gen_lsp_server

crates/gen_lsp_server/Cargo.toml

@@ -0,0 +1,14 @@
+[package]
+name = "gen_lsp_server"
+version = "0.1.0"
+authors = ["Aleksey Kladov <aleksey.kladov@gmail.com>"]
+
+[dependencies]
+languageserver-types = "0.49.0"
+log = "0.4.3"
+
+failure = "0.1.2"
+serde_json = "1.0.24"
+serde = "1.0.71"
+serde_derive = "1.0.71"
+crossbeam-channel = "0.2.4"

crates/gen_lsp_server/src/lib.rs

@@ -0,0 +1,77 @@
+#[macro_use]
+extern crate failure;
+#[macro_use]
+extern crate log;
+extern crate serde;
+extern crate serde_json;
+#[macro_use]
+extern crate serde_derive;
+extern crate crossbeam_channel;
+extern crate languageserver_types;
+
+mod msg;
+mod stdio;
+
+use crossbeam_channel::{Sender, Receiver};
+use languageserver_types::{
+    ServerCapabilities, InitializeResult,
+    request::{Initialize},
+    notification::{Initialized, Exit},
+};
+
+pub type Result<T> = ::std::result::Result<T, failure::Error>;
+pub use {
+    msg::{RawMessage, RawRequest, RawResponse, RawResponseError, RawNotification},
+    stdio::{stdio_transport, Threads},
+};
+
+pub type LspServer = fn(&mut Receiver<RawMessage>, &mut Sender<RawMessage>) -> Result<()>;
+
+pub fn run_server(
+    caps: ServerCapabilities,
+    server: LspServer,
+    mut receiver: Receiver<RawMessage>,
+    mut sender: Sender<RawMessage>,
+) -> Result<()> {
+    info!("lsp server initializes");
+    initialize(&mut receiver, &mut sender, caps)?;
+    info!("lsp server initialized, serving requests");
+    server(&mut receiver, &mut sender)?;
+    info!("lsp server waiting for exit notification");
+    match receiver.recv() {
+        Some(RawMessage::Notification(n)) => {
+            n.cast::<Exit>().map_err(|n| format_err!(
+                "unexpected notification during shutdown: {:?}", n
+            ))?
+        }
+        m => bail!("unexpected message during shutdown: {:?}", m)
+    }
+    info!("lsp server shutdown complete");
+    Ok(())
+}
+
+fn initialize(
+    receiver: &mut Receiver<RawMessage>,
+    sender: &mut Sender<RawMessage>,
+    caps: ServerCapabilities,
+) -> Result<()> {
+    let id = match receiver.recv() {
+        Some(RawMessage::Request(req)) => match req.cast::<Initialize>() {
+            Err(req) => bail!("expected initialize request, got {:?}", req),
+            Ok(req) => req.0,
+        }
+        msg =>
+            bail!("expected initialize request, got {:?}", msg),
+    };
+    let resp = RawResponse::ok(id, InitializeResult { capabilities: caps });
+    sender.send(RawMessage::Response(resp));
+    match receiver.recv() {
+        Some(RawMessage::Notification(n)) => {
+            n.cast::<Initialized>().map_err(|_| format_err!(
+                "expected initialized notification"
+            ))?;
+        }
+        _ => bail!("expected initialized notification"),
+    }
+    Ok(())
+}

crates/gen_lsp_server/src/msg.rs

@@ -0,0 +1,172 @@
+use std::io::{BufRead, Write};
+
+use serde_json::{Value, from_str, to_string, from_value, to_value};
+use serde::{Serialize, de::DeserializeOwned};
+use languageserver_types::{
+    request::Request,
+    notification::Notification,
+};
+
+use Result;
+
+#[derive(Debug, Serialize, Deserialize)]
+#[serde(untagged)]
+pub enum RawMessage {
+    Request(RawRequest),
+    Notification(RawNotification),
+    Response(RawResponse),
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct RawRequest {
+    pub id: u64,
+    pub method: String,
+    pub params: Value,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct RawResponse {
+    // JSON RPC allows this to be null if it was impossible
+    // to decode the request's id. Ignore this special case
+    // and just die horribly.
+    pub id: u64,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub result: Option<Value>,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub error: Option<RawResponseError>,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct RawResponseError {
+    pub code: i32,
+    pub message: String,
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub data: Option<Value>,
+}
+
+#[allow(unused)]
+pub enum ErrorCode {
+    ParseError = -32700,
+    InvalidRequest = -32600,
+    MethodNotFound = -32601,
+    InvalidParams = -32602,
+    InternalError = -32603,
+    ServerErrorStart = -32099,
+    ServerErrorEnd = -32000,
+    ServerNotInitialized = -32002,
+    UnknownErrorCode = -32001,
+    RequestCancelled = -32800,
+}
+
+#[derive(Debug, Serialize, Deserialize)]
+pub struct RawNotification {
+    pub method: String,
+    pub params: Value,
+}
+
+impl RawMessage {
+    pub fn read(r: &mut impl BufRead) -> Result<Option<RawMessage>> {
+        let text = match read_msg_text(r)? {
+            None => return Ok(None),
+            Some(text) => text,
+        };
+        let msg = from_str(&text)?;
+        Ok(Some(msg))
+    }
+    pub fn write(self, w: &mut impl Write) -> Result<()> {
+        #[derive(Serialize)]
+        struct JsonRpc {
+            jsonrpc: &'static str,
+            #[serde(flatten)]
+            msg: RawMessage,
+        }
+        let text = to_string(&JsonRpc { jsonrpc: "2.0", msg: self })?;
+        write_msg_text(w, &text)?;
+        Ok(())
+    }
+}
+
+impl RawRequest {
+    pub fn cast<R>(self) -> ::std::result::Result<(u64, R::Params), RawRequest>
+    where
+        R: Request,
+        R::Params: DeserializeOwned,
+    {
+        if self.method != R::METHOD {
+            return Err(self);
+        }
+        let id = self.id;
+        let params: R::Params = from_value(self.params).unwrap();
+        Ok((id, params))
+    }
+}
+
+impl RawResponse {
+    pub fn ok(id: u64, result: impl Serialize) -> RawResponse {
+        RawResponse {
+            id,
+            result: Some(to_value(&result).unwrap()),
+            error: None,
+        }
+    }
+    pub fn err(id: u64, code: i32, message: String) -> RawResponse {
+        let error = RawResponseError { code, message, data: None };
+        RawResponse {
+            id,
+            result: None,
+            error: Some(error),
+        }
+    }
+}
+
+impl RawNotification {
+    pub fn cast<N>(self) -> ::std::result::Result<N::Params, RawNotification>
+    where
+        N: Notification,
+        N::Params: DeserializeOwned,
+    {
+        if self.method != N::METHOD {
+            return Err(self);
+        }
+        Ok(from_value(self.params).unwrap())
+    }
+}
+
+fn read_msg_text(inp: &mut impl BufRead) -> Result<Option<String>> {
+    let mut size = None;
+    let mut buf = String::new();
+    loop {
+        buf.clear();
+        if inp.read_line(&mut buf)? == 0 {
+            return Ok(None);
+        }
+        if !buf.ends_with("\r\n") {
+            bail!("malformed header: {:?}", buf);
+        }
+        let buf = &buf[..buf.len() - 2];
+        if buf.is_empty() {
+            break;
+        }
+        let mut parts = buf.splitn(2, ": ");
+        let header_name = parts.next().unwrap();
+        let header_value = parts.next().ok_or_else(|| format_err!("malformed header: {:?}", buf))?;
+        if header_name == "Content-Length" {
+            size = Some(header_value.parse::<usize>()?);
+        }
+    }
+    let size = size.ok_or_else(|| format_err!("no Content-Length"))?;
+    let mut buf = buf.into_bytes();
+    buf.resize(size, 0);
+    inp.read_exact(&mut buf)?;
+    let buf = String::from_utf8(buf)?;
+    debug!("< {}", buf);
+    Ok(Some(buf))
+}
+
+fn write_msg_text(out: &mut impl Write, msg: &str) -> Result<()> {
+    debug!("> {}", msg);
+    write!(out, "Content-Length: {}\r\n\r\n", msg.len())?;
+    out.write_all(msg.as_bytes())?;
+    out.flush()?;
+    Ok(())
+}

crates/gen_lsp_server/src/stdio.rs

@@ -0,0 +1,49 @@
+use std::{
+    thread,
+    io::{
+        stdout, stdin,
+    },
+};
+
+use crossbeam_channel::{Receiver, Sender, bounded};
+
+use {RawMessage, Result};
+
+pub fn stdio_transport() -> (Receiver<RawMessage>, Sender<RawMessage>, Threads) {
+    let (writer_sender, mut writer_receiver) = bounded::<RawMessage>(16);
+    let writer = thread::spawn(move || {
+        let stdout = stdout();
+        let mut stdout = stdout.lock();
+        writer_receiver.try_for_each(|it| it.write(&mut stdout))?;
+        Ok(())
+    });
+    let (reader_sender, reader_receiver) = bounded::<RawMessage>(16);
+    let reader = thread::spawn(move || {
+        let stdin = stdin();
+        let mut stdin = stdin.lock();
+        while let Some(msg) = RawMessage::read(&mut stdin)? {
+            reader_sender.send(msg);
+        }
+        Ok(())
+    });
+    let threads = Threads { reader, writer };
+    (reader_receiver, writer_sender, threads)
+}
+
+pub struct Threads {
+    reader: thread::JoinHandle<Result<()>>,
+    writer: thread::JoinHandle<Result<()>>,
+}
+
+impl Threads {
+    pub fn join(self) -> Result<()> {
+        match self.reader.join() {
+            Ok(r) => r?,
+            Err(_) => bail!("reader panicked"),
+        }
+        match self.writer.join() {
+            Ok(r) => r,
+            Err(_) => bail!("writer panicked"),
+        }
+    }
+}