feat: new protocol for proc-macro-api

Author: DriedYellowPeach

Cargo.lock

@@ -14,6 +14,7 @@ rust-version.workspace = true
 [dependencies]
 serde.workspace = true
 serde_derive.workspace = true
+postcard = { version = "1.1.1", features = ["alloc"] }
 serde_json = { workspace = true, features = ["unbounded_depth"] }
 tracing.workspace = true
 rustc-hash.workspace = true
@@ -24,7 +25,7 @@ paths = { workspace = true, features = ["serde1"] }
 tt.workspace = true
 stdx.workspace = true
 # span = {workspace = true, default-features = false} does not work
-span = { path = "../span", version = "0.0.0", default-features = false}
+span = { path = "../span", version = "0.0.0", default-features = false }
 
 intern.workspace = true
 

crates/proc-macro-api/Cargo.toml

@@ -0,0 +1,64 @@
+//! Implement how to send and receive legacy protocol message on stdio stream(protocol layer)
+//!
+//! The implementation follows:
+//! 1. Send Request
+//! 2. Receive Response
+
+use std::{
+    io::{self, BufRead, Write},
+    sync::Arc,
+};
+
+use crate::{
+    ServerError,
+    legacy_protocol::{
+        json::{read_json, write_json},
+        msg::{Request, Response},
+    },
+    task::TaskClient,
+};
+
+/// Sends a request to the server and reads the response.
+fn send_request(
+    mut writer: &mut dyn Write,
+    mut reader: &mut dyn BufRead,
+    req: Request,
+    buf: &mut String,
+) -> Result<Option<Response>, ServerError> {
+    use crate::legacy_protocol::msg::Message;
+
+    req.write(write_json, &mut writer).map_err(|err| ServerError {
+        message: "failed to write request".into(),
+        io: Some(Arc::new(err)),
+    })?;
+    let res = Response::read(read_json, &mut reader, buf).map_err(|err| ServerError {
+        message: "failed to read response".into(),
+        io: Some(Arc::new(err)),
+    })?;
+    Ok(res)
+}
+
+pub struct JsonTaskClient<'a> {
+    pub writer: &'a mut dyn Write,
+    pub reader: &'a mut dyn BufRead,
+    pub buf: &'a mut String,
+}
+
+impl TaskClient for JsonTaskClient<'_> {
+    type Task = Request;
+    type TaskResult = Response;
+
+    // Implement send_task for Json Legacy Protocol
+    // Basically what we have done in process.rs
+    fn send_task(&mut self, task: Self::Task) -> Result<Self::TaskResult, ServerError> {
+        send_request(self.writer, self.reader, task, self.buf).and_then(|res| {
+            res.ok_or_else(|| {
+                let message = "proc-macro server did not respond with data".to_owned();
+                ServerError {
+                    io: Some(Arc::new(io::Error::new(io::ErrorKind::BrokenPipe, message.clone()))),
+                    message,
+                }
+            })
+        })
+    }
+}

crates/proc-macro-api/src/legacy_protocol/task_impl.rs

@@ -8,7 +8,19 @@
 pub mod legacy_protocol {
     pub mod json;
     pub mod msg;
+    pub mod task_impl;
 }
+
+#[allow(dead_code)]
+pub mod new_protocol {
+    pub mod encoding;
+    pub mod msg;
+    pub mod task_impl;
+}
+
+#[allow(dead_code)]
+pub mod task;
+
 mod process;
 
 use paths::{AbsPath, AbsPathBuf};

crates/proc-macro-api/src/lib.rs

@@ -0,0 +1,42 @@
+//! Implement how to encoding and decoding new protocol message on stdio stream
+//!
+//! Current implementation encoded message to | message length | message content |
+
+use serde::de::DeserializeOwned;
+use std::io::{self, BufRead, Read, Write};
+
+use super::msg::{C2SMsg, S2CMsg};
+
+fn read_usize_be<R: Read + ?Sized>(reader: &mut R) -> io::Result<usize> {
+    let mut buf = [0u8; std::mem::size_of::<usize>()];
+    reader.read_exact(&mut buf)?;
+    Ok(usize::from_be_bytes(buf))
+}
+
+fn write_usize_be<W: Write + ?Sized>(writer: &mut W, value: usize) -> io::Result<()> {
+    writer.write_all(&value.to_be_bytes()) // Convert and write as Big-Endian
+}
+
+pub trait CodexPostcard: serde::Serialize + DeserializeOwned {
+    fn receive_proto<R: BufRead + ?Sized>(reader: &mut R) -> io::Result<Self> {
+        let msg_len = read_usize_be(reader)? as usize;
+        let mut buf = vec![0u8; msg_len];
+
+        reader.read_exact(&mut buf)?;
+        postcard::from_bytes::<Self>(&buf)
+            .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))
+    }
+
+    fn send_proto<W: Write + ?Sized>(&self, writer: &mut W) -> io::Result<()> {
+        let bytes = postcard::to_allocvec(self)
+            .map_err(|e| io::Error::new(io::ErrorKind::InvalidData, e))?;
+
+        write_usize_be(writer, bytes.len())?;
+        writer.write_all(&bytes)?;
+        writer.flush()
+    }
+}
+
+// NOTE: With default implementation, C2SMsg and S2CMsg can both be send through stdio
+impl CodexPostcard for C2SMsg {}
+impl CodexPostcard for S2CMsg {}