rust-analyzer

diff --git a/crates/proc-macro-api/src/bidirectional_protocol.rs b/crates/proc-macro-api/src/bidirectional_protocol.rs
index a13bff7d7d..8311df23d7 100644
--- a/crates/proc-macro-api/src/bidirectional_protocol.rs
+++ b/crates/proc-macro-api/src/bidirectional_protocol.rs

@@ -9,7 +9,7 @@ use paths::AbsPath;

use span::Span;

use crate::{

- Codec, ProcMacro, ProcMacroKind, ServerError,

+ ProcMacro, ProcMacroKind, ServerError,

bidirectional_protocol::msg::{

BidirectionalMessage, ExpandMacro, ExpandMacroData, ExpnGlobals, Request, Response,

SubRequest, SubResponse,

@@ -22,25 +22,25 @@ use crate::{

process::ProcMacroServerProcess,

- transport::codec::postcard::PostcardProtocol,

+ transport::postcard,

};

pub mod msg;

pub type SubCallback<'a> = &'a dyn Fn(SubRequest) -> Result<SubResponse, ServerError>;

-pub fn run_conversation<C: Codec>(

+pub fn run_conversation(

writer: &mut dyn Write,

reader: &mut dyn BufRead,

- buf: &mut C::Buf,

+ buf: &mut Vec<u8>,

msg: BidirectionalMessage,

callback: SubCallback<'_>,

) -> Result<BidirectionalMessage, ServerError> {

- let encoded = C::encode(&msg).map_err(wrap_encode)?;

- C::write(writer, &encoded).map_err(wrap_io("failed to write initial request"))?;

+ let encoded = postcard::encode(&msg).map_err(wrap_encode)?;

+ postcard::write(writer, &encoded).map_err(wrap_io("failed to write initial request"))?;

loop {

- let maybe_buf = C::read(reader, buf).map_err(wrap_io("failed to read message"))?;

+ let maybe_buf = postcard::read(reader, buf).map_err(wrap_io("failed to read message"))?;

let Some(b) = maybe_buf else {

return Err(ServerError {

message: "proc-macro server closed the stream".into(),

@@ -48,7 +48,7 @@ pub fn run_conversation<C: Codec>(

});

};

- let msg: BidirectionalMessage = C::decode(b).map_err(wrap_decode)?;

+ let msg: BidirectionalMessage = postcard::decode(b).map_err(wrap_decode)?;

match msg {

BidirectionalMessage::Response(response) => {

@@ -57,8 +57,9 @@ pub fn run_conversation<C: Codec>(

BidirectionalMessage::SubRequest(sr) => {

let resp = callback(sr)?;

let reply = BidirectionalMessage::SubResponse(resp);

- let encoded = C::encode(&reply).map_err(wrap_encode)?;

- C::write(writer, &encoded).map_err(wrap_io("failed to write sub-response"))?;

+ let encoded = postcard::encode(&reply).map_err(wrap_encode)?;

+ postcard::write(writer, &encoded)

+ .map_err(wrap_io("failed to write sub-response"))?;

}

_ => {

return Err(ServerError {

@@ -207,7 +208,7 @@ fn run_request(

if let Some(err) = srv.exited() {

return Err(err.clone());

}

- srv.run_bidirectional::<PostcardProtocol>(msg, callback)

+ srv.run_bidirectional(msg, callback)

}

pub fn reject_subrequests(req: SubRequest) -> Result<SubResponse, ServerError> {

diff --git a/crates/proc-macro-api/src/bidirectional_protocol/msg.rs b/crates/proc-macro-api/src/bidirectional_protocol/msg.rs
index d030498e59..1df0c68379 100644
--- a/crates/proc-macro-api/src/bidirectional_protocol/msg.rs
+++ b/crates/proc-macro-api/src/bidirectional_protocol/msg.rs

@@ -1,6 +1,9 @@

//! Bidirectional protocol messages

-use std::ops::Range;

+use std::{

+ io::{self, BufRead, Write},

+ ops::Range,

+};

use paths::Utf8PathBuf;

use serde::{Deserialize, Serialize};

@@ -8,6 +11,7 @@ use serde::{Deserialize, Serialize};

use crate::{

ProcMacroKind,

legacy_protocol::msg::{FlatTree, Message, PanicMessage, ServerConfig},

+ transport::postcard,

};

#[derive(Debug, Serialize, Deserialize)]

@@ -97,4 +101,17 @@ pub struct ExpnGlobals {

pub mixed_site: usize,

}

-impl Message for BidirectionalMessage {}

+impl Message for BidirectionalMessage {

+ type Buf = Vec<u8>;

+ fn read(inp: &mut dyn BufRead, buf: &mut Self::Buf) -> io::Result<Option<Self>> {

+ Ok(match postcard::read(inp, buf)? {

+ None => None,

+ Some(buf) => Some(postcard::decode(buf)?),

+ })

+ }

+ fn write(self, out: &mut dyn Write) -> io::Result<()> {

+ let value = postcard::encode(&self)?;

+ postcard::write(out, &value)

+ }

diff --git a/crates/proc-macro-api/src/legacy_protocol.rs b/crates/proc-macro-api/src/legacy_protocol.rs
index eedf66d460..ee1795d39c 100644
--- a/crates/proc-macro-api/src/legacy_protocol.rs
+++ b/crates/proc-macro-api/src/legacy_protocol.rs

@@ -18,8 +18,6 @@ use crate::{

flat::serialize_span_data_index_map,

process::ProcMacroServerProcess,

- transport::codec::Codec,

- transport::codec::json::JsonProtocol,

version,

};

@@ -149,21 +147,21 @@ fn send_task(srv: &ProcMacroServerProcess, req: Request) -> Result<Response, Ser

return Err(server_error.clone());

}

- srv.send_task::<_, _, JsonProtocol>(send_request::<JsonProtocol>, req)

+ srv.send_task_legacy::<_, _>(send_request, req)

}

/// Sends a request to the server and reads the response.

-fn send_request<P: Codec>(

+fn send_request(

mut writer: &mut dyn Write,

mut reader: &mut dyn BufRead,

req: Request,

- buf: &mut P::Buf,

+ buf: &mut String,

) -> Result<Option<Response>, ServerError> {

- req.write::<P>(&mut writer).map_err(|err| ServerError {

+ req.write(&mut writer).map_err(|err| ServerError {

message: "failed to write request".into(),

io: Some(Arc::new(err)),

})?;

- let res = Response::read::<P>(&mut reader, buf).map_err(|err| ServerError {

+ let res = Response::read(&mut reader, buf).map_err(|err| ServerError {

message: "failed to read response".into(),

io: Some(Arc::new(err)),

})?;

diff --git a/crates/proc-macro-api/src/legacy_protocol/msg.rs b/crates/proc-macro-api/src/legacy_protocol/msg.rs
index 1b65906933..bb0dde4728 100644
--- a/crates/proc-macro-api/src/legacy_protocol/msg.rs
+++ b/crates/proc-macro-api/src/legacy_protocol/msg.rs

@@ -8,7 +8,7 @@ use paths::Utf8PathBuf;

use serde::de::DeserializeOwned;

use serde_derive::{Deserialize, Serialize};

-use crate::{Codec, ProcMacroKind};

+use crate::{ProcMacroKind, transport::json};

/// Represents requests sent from the client to the proc-macro-srv.

#[derive(Debug, Serialize, Deserialize)]

@@ -155,20 +155,40 @@ impl ExpnGlobals {

}

pub trait Message: serde::Serialize + DeserializeOwned {

- fn read<C: Codec>(inp: &mut dyn BufRead, buf: &mut C::Buf) -> io::Result<Option<Self>> {

- Ok(match C::read(inp, buf)? {

+ type Buf;

+ fn read(inp: &mut dyn BufRead, buf: &mut Self::Buf) -> io::Result<Option<Self>>;

+ fn write(self, out: &mut dyn Write) -> io::Result<()>;

+impl Message for Request {

+ type Buf = String;

+ fn read(inp: &mut dyn BufRead, buf: &mut Self::Buf) -> io::Result<Option<Self>> {

+ Ok(match json::read(inp, buf)? {

None => None,

- Some(buf) => Some(C::decode(buf)?),

+ Some(buf) => Some(json::decode(buf)?),

})

}

- fn write<C: Codec>(self, out: &mut dyn Write) -> io::Result<()> {

- let value = C::encode(&self)?;

- C::write(out, &value)

+ fn write(self, out: &mut dyn Write) -> io::Result<()> {

+ let value = json::encode(&self)?;

+ json::write(out, &value)

}

-impl Message for Request {}

-impl Message for Response {}

+impl Message for Response {

+ type Buf = String;

+ fn read(inp: &mut dyn BufRead, buf: &mut Self::Buf) -> io::Result<Option<Self>> {

+ Ok(match json::read(inp, buf)? {

+ None => None,

+ Some(buf) => Some(json::decode(buf)?),

+ })

+ }

+ fn write(self, out: &mut dyn Write) -> io::Result<()> {

+ let value = json::encode(&self)?;

+ json::write(out, &value)

+ }

#[cfg(test)]

mod tests {

diff --git a/crates/proc-macro-api/src/lib.rs b/crates/proc-macro-api/src/lib.rs
index 3acd0b292a..e4b121b033 100644
--- a/crates/proc-macro-api/src/lib.rs
+++ b/crates/proc-macro-api/src/lib.rs

@@ -27,7 +27,6 @@ use semver::Version;

use span::{ErasedFileAstId, FIXUP_ERASED_FILE_AST_ID_MARKER, Span};

use std::{fmt, io, sync::Arc, time::SystemTime};

-pub use crate::transport::codec::Codec;

use crate::{

bidirectional_protocol::SubCallback, pool::ProcMacroServerPool, process::ProcMacroServerProcess,

};

diff --git a/crates/proc-macro-api/src/process.rs b/crates/proc-macro-api/src/process.rs
index 2f5bef69ab..9f80880965 100644
--- a/crates/proc-macro-api/src/process.rs
+++ b/crates/proc-macro-api/src/process.rs

@@ -17,7 +17,7 @@ use span::Span;

use stdx::JodChild;

use crate::{

- Codec, ProcMacro, ProcMacroKind, ProtocolFormat, ServerError,

+ ProcMacro, ProcMacroKind, ProtocolFormat, ServerError,

bidirectional_protocol::{self, SubCallback, msg::BidirectionalMessage, reject_subrequests},

legacy_protocol::{self, SpanMode},

version,

@@ -305,17 +305,17 @@ impl ProcMacroServerProcess {

result

}

- pub(crate) fn send_task<Request, Response, C: Codec>(

+ pub(crate) fn send_task_legacy<Request, Response>(

&self,

send: impl FnOnce(

&mut dyn Write,

&mut dyn BufRead,

Request,

- &mut C::Buf,

+ &mut String,

) -> Result<Option<Response>, ServerError>,

req: Request,

) -> Result<Response, ServerError> {

- self.with_locked_io::<C, _>(|writer, reader, buf| {

+ self.with_locked_io(String::new(), |writer, reader, buf| {

send(writer, reader, req, buf).and_then(|res| {

res.ok_or_else(|| {

let message = "proc-macro server did not respond with data".to_owned();

@@ -331,13 +331,12 @@ impl ProcMacroServerProcess {

})

}

- pub(crate) fn with_locked_io<C: Codec, R>(

+ fn with_locked_io<R, B>(

&self,

- f: impl FnOnce(&mut dyn Write, &mut dyn BufRead, &mut C::Buf) -> Result<R, ServerError>,

+ mut buf: B,

+ f: impl FnOnce(&mut dyn Write, &mut dyn BufRead, &mut B) -> Result<R, ServerError>,

) -> Result<R, ServerError> {

let state = &mut *self.state.lock().unwrap();

- let mut buf = C::Buf::default();

f(&mut state.stdin, &mut state.stdout, &mut buf).map_err(|e| {

if e.io.as_ref().map(|it| it.kind()) == Some(io::ErrorKind::BrokenPipe) {

match state.process.exit_err() {

@@ -352,13 +351,13 @@ impl ProcMacroServerProcess {

})

}

- pub(crate) fn run_bidirectional<C: Codec>(

+ pub(crate) fn run_bidirectional(

&self,

initial: BidirectionalMessage,

callback: SubCallback<'_>,

) -> Result<BidirectionalMessage, ServerError> {

- self.with_locked_io::<C, _>(|writer, reader, buf| {

- bidirectional_protocol::run_conversation::<C>(writer, reader, buf, initial, callback)

+ self.with_locked_io(Vec::new(), |writer, reader, buf| {

+ bidirectional_protocol::run_conversation(writer, reader, buf, initial, callback)

})

}

diff --git a/crates/proc-macro-api/src/transport.rs b/crates/proc-macro-api/src/transport.rs
index b7a1d8f732..e31d6a589d 100644
--- a/crates/proc-macro-api/src/transport.rs
+++ b/crates/proc-macro-api/src/transport.rs

@@ -1,3 +1,3 @@

//! Contains construct for transport of messages.

-pub mod codec;

-pub mod framing;

+pub mod json;

+pub mod postcard;