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 msg;
+    pub mod postcard;
+    pub mod task_impl;
+}
+
+#[allow(dead_code)]
+pub mod task;
+
 mod process;
 
 use paths::{AbsPath, AbsPathBuf};